Five layers. Zero shortcuts.

// Audio capture pipeline — verified compatible with Gemma 4 multimodal
private fun captureAudioForGemma(): ByteArray {
    val sampleRate = 16000   // 16 kHz mono (Gemma 4 USM encoder spec)
    val bitsPerSample = 16
    val channels = 1

    // PCM → WAV (Gemma 4 multimodal audio input requires a container)
    // Reference: Google AI Edge Gallery ChatMessage.kt:187 genByteArrayForWav
    val byteRate = sampleRate * channels * bitsPerSample / 8  // = 32000
    val wavHeader = buildRiffHeader(pcm.size, sampleRate, channels, bitsPerSample)
    return wavHeader + pcm
}

// Send to Gemma 4 with audio Content
val engineConfig = EngineConfig.Builder()
    .setModelPath(modelPath)
    .setAudioBackend(Backend.CPU())   // required for audio decoding
    .build()
val content = Content.audioBytes(audioBytes)  // not raw PCM!

@Tool(
    description = "MASTER cross-check: given a candidate drug name, " +
                  "check it against ALL three pillars of the focus profile " +
                  "(allergies, current medications for DDI, and known " +
                  "conditions for contraindications). Returns a structured " +
                  "collision report. Call this whenever the rescuer scans " +
                  "a new medication or considers giving a drug to the patient."
)
fun checkOneDrugAgainstFocusProfile(
    @ToolParam(description = "Candidate drug — common name (any language), " +
                             "brand, INN, or RxNorm/ATC code.")
    drugName: String
): Map<String, Any> = runBlocking(Dispatchers.IO) {
    val p = focusRef.get() ?: return@runBlocking profileMissingMap()
    val lang = currentLang()
    val tStart = System.currentTimeMillis()
    val result = xcheck.checkOneDrugAgainstProfile(
        drugName, p.al, p.md, p.cn, lang
    )
    Log.i(TAG, "[t=${System.currentTimeMillis()}] " +
        "🚨 checkOneDrugAgainstFocusProfile('$drugName') → " +
        "🩹${result.allergyHits.size} 💊${result.ddiHits.size} " +
        "🦠${result.drugDiseaseHits.size} · " +
        "${System.currentTimeMillis() - tStart}ms")
    crossCheckResultToMap(result, drugName, lang)
}

@Tool(
    description = "Resolve a drug name (any language, brand, INN, " +
                  "RxNorm or ATC code) to its KB entry. Returns ATC, " +
                  "RxNorm, canonical and localized display. Always call " +
                  "this first when only a free-text drug name is available " +
                  "before invoking checkDdi or any cross-check tool."
)
fun resolveDrug(
    @ToolParam(description = "Drug name in any supported language, " +
                             "or a code (RxNorm CUI, ATC).")
    name: String
): String {
    emitStep(JemmaToolEvent.ToolStart("resolveDrug", mapOf("name" to name)))
    val candidate = kb.resolveDrugByAnyName(name)
        ?: return jsonError("No KB entry for '$name'.")

    // Walk ATC hierarchy upward (for class-level allergy matches)
    val ancestors = kb.getAtcAncestors(candidate.atc)
    val result = JemmaDrugResult(
        rxnormCui = candidate.rxnorm,
        atc = candidate.atc,
        atcAncestors = ancestors,
        canonicalName = candidate.canonical,
        localizedDisplays = candidate.displays
    )
    emitStep(JemmaToolEvent.ToolEnd("resolveDrug", result))
    return moshi.toJson(result)
}

-- The "emergency view" — 802,352 rows · queried in <50ms via indexed ATC lookup
CREATE VIEW v_ddi_emergency AS
    SELECT  p.drug_a_atc, p.drug_b_atc, f.severity, f.mechanism_category,
            f.description_en, f.management_en, f.alternative_atc
    FROM    ddi_atc_pairs p
    JOIN    ddi_facts f USING (fact_id)
    WHERE   f.severity IN ('Major', 'Moderate');

-- Used in JemmaTools.checkDdi() — single statement, indexed on (drug_a_atc, drug_b_atc)
SELECT severity, mechanism_category, description_en, management_en, alternative_atc
FROM   v_ddi_emergency
WHERE  (drug_a_atc = ? AND drug_b_atc = ?)
   OR  (drug_a_atc = ? AND drug_b_atc = ?)
LIMIT 1;

// 16 KB page-size aligned (verified with llvm-objdump on Pixel 9 Pro XL)
//   align 2**14  ← required for Android 15+ (Google Play Nov 2025)
implementation("com.github.requery:sqlite-android:3.49.0")

/**
 * Encode a JemmaProfileJ to wire format _j2:<base64-url(deflate-raw(JSON))>.
 *
 * Pipeline:
 *   1. Moshi serializes the profile to JSON
 *   2. Pruner strips empty arrays / default values
 *   3. Deflater(nowrap=true) → deflate-raw RFC 1951 bytes
 *   4. base64-url encoding (no padding, URL-safe alphabet)
 *   5. prefix _j2: → final string fits in a single QR
 */
fun encode(profile: JemmaProfileJ): EncodeResult {
    val rawJson = moshi.adapter(JemmaProfileJ::class.java).toJson(profile)
    val prunedJson = JemmaPayloadPruner.smartPrune(rawJson)

    val deflater = Deflater(Deflater.BEST_COMPRESSION, true)  // nowrap=true
    deflater.setInput(prunedJson.toByteArray(Charsets.UTF_8))
    deflater.finish()

    val out = ByteArrayOutputStream()
    val buffer = ByteArray(1024)
    while (!deflater.finished()) {
        out.write(buffer, 0, deflater.deflate(buffer))
    }
    deflater.end()

    val b64url = Base64.getUrlEncoder().withoutPadding().encodeToString(out.toByteArray())
    return EncodeResult.Success(
        wire = "_j2:$b64url",
        rawSize = rawJson.length,
        prunedSize = prunedJson.length,
        compressedSize = out.size()
    )
}

enum class ChunkType(val prefix: String, val isRelayed: Boolean) {
    /** Direct victim profile chunk (5-chunk rotation, no relay).
     *  Format: V|<sid4>|<chunkIdx>|<chunkTotal>|<payload> */
    VICTIM_DIRECT  ("V",  isRelayed = false),

    /** Multi-hop relayed victim chunk (carries TTL).
     *  Format: VR|<sid4>|<chunkIdx>|<chunkTotal>|<ttl>|<payload> */
    VICTIM_RELAYED ("VR", isRelayed = true),

    /** Direct rescuer beacon (single chunk).
     *  Format: S|<sid4>|<name_ascii>|<lang>|<lat>|<lon> */
    RESCUER_DIRECT ("S",  isRelayed = false),

    /** Multi-hop relayed rescuer beacon.
     *  Format: SR|<sid4>|<name_ascii>|<lang>|<lat>|<lon>|<ttl> */
    RESCUER_RELAYED("SR", isRelayed = true),

    /** Triage event (status change, HELP, STAB, EVAC, DCD…).
     *  Format: E|<source>|<victim>|<status>|<rescuer>|<ts>|<ttl>|<seq> */
    EVENT          ("E",  isRelayed = false),

    /** Profile fingerprint advertisement (cache-skip optimization).
     *  Format: F|<sid>|<sha256_hex_8>|<lastModifiedTs>|<chunkVersion>
     *  Sent every 10s vs 1.5s for V| → ~75 broadcasts saved per cache hit. */
    FINGERPRINT    ("F",  isRelayed = false);
}

companion object {
    // P2P_CLUSTER: M-to-N topology, mesh-friendly, small payloads.
    // Google Nearby docs: "ideal for mesh-like experiences"
    const val SERVICE_ID = "be.heyman.android.jemmapassdemo.sos.SOS"
    val STRATEGY: Strategy = Strategy.P2P_CLUSTER

    // 131-byte endpointName cap (BLE advertising packet constraint).
    // We rotate through 5 chunks of a victim profile, every 1.5s.
    // Full cycle = 5 × 1500ms = 7.5s, well under the 9s discovery timeout.
    const val CHUNK_ROTATION_MS = 1500L
}

<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minWidth="250dp"
    android:minHeight="110dp"
    android:targetCellWidth="4"
    android:targetCellHeight="2"
    android:resizeMode="horizontal|vertical"
    android:widgetCategory="home_screen|keyguard"
    android:updatePeriodMillis="1800000"
    android:initialLayout="@layout/jemma_emergency_widget"
    android:initialKeyguardLayout="@layout/jemma_emergency_widget"
    android:previewLayout="@layout/jemma_emergency_widget" />

private const val DOUBLE_TAP_TIMEOUT = 2000L
private var lastTapTime = 0L

override fun onReceive(context: Context, intent: Intent) {
    super.onReceive(context, intent)
    if (intent.action == ACTION_SOS_TAP) {
        val now = System.currentTimeMillis()
        if (now - lastTapTime < DOUBLE_TAP_TIMEOUT) {
            // Double tap confirmed — start the emergency service.
            Log.i(TAG, "Double tap confirmed, starting emergency service")
            lastTapTime = 0L
            startEmergencyService(context, appWidgetId)
        } else {
            // First tap — arm the widget, await second tap.
            lastTapTime = now
        }
    }
}