@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/src/main/java/com/glassly/bluetoothsdk/sgcs/G2Flasher.kt

@@ -0,0 +1,411 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCharacteristic
+import android.content.Context
+import android.os.Build
+import com.glassly.bluetoothsdk.Bridge
+import java.security.MessageDigest
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+internal data class G2FirmwareArtifact(
+    val id: String,
+    val displayName: String,
+    val version: String,
+    val fileName: String,
+    val sha256: String,
+    val size: Int,
+) {
+    fun toMap(): Map<String, Any> =
+        mapOf(
+            "id" to id,
+            "displayName" to displayName,
+            "version" to version,
+            "fileName" to fileName,
+            "sha256" to sha256,
+            "size" to size,
+        )
+}
+
+internal object G2FirmwareCatalog {
+    private const val ASSET_DIRECTORY = "G2Firmware"
+
+    val artifacts =
+        listOf(
+            G2FirmwareArtifact(
+                id = "stock",
+                displayName = "Stock firmware",
+                version = "2.2.6.10",
+                fileName = "g2-stock-2.2.6.10.evenota.bin",
+                sha256 = "f4dfb0b49ad3de3c2daf17f8a27a157c3dc98411d6a0d3ab2cfd0918f41b9afa",
+                size = 4_301_227,
+            ),
+            G2FirmwareArtifact(
+                id = "glassly-cfw",
+                displayName = "Glassly CFW",
+                version = "2.2.6.10 CFW",
+                fileName = "g2-glassly-cfw-2.2.6.10.evenota.bin",
+                sha256 = "82726bbe4d1d82f06a3d345ba3e5a4a39161077e5d26dcd7af24c4677df87fd1",
+                size = 4_336_071,
+            ),
+        )
+
+    fun artifact(id: String): G2FirmwareArtifact =
+        artifacts.firstOrNull { it.id == id }
+            ?: throw G2FirmwareFlashException("Unknown G2 firmware target: $id")
+
+    fun load(context: Context, artifact: G2FirmwareArtifact): ByteArray {
+        val data =
+            try {
+                context.assets.open("$ASSET_DIRECTORY/${artifact.fileName}").use { it.readBytes() }
+            } catch (error: Exception) {
+                throw G2FirmwareFlashException(
+                    "Bundled firmware ${artifact.fileName} is missing from the app.",
+                    error,
+                )
+            }
+        if (data.size != artifact.size) {
+            throw G2FirmwareFlashException(
+                "${artifact.displayName} size mismatch: expected ${artifact.size}, got ${data.size}"
+            )
+        }
+        val digest =
+            MessageDigest.getInstance("SHA-256").digest(data).joinToString("") {
+                "%02x".format(it.toInt() and 0xFF)
+            }
+        if (digest != artifact.sha256) {
+            throw G2FirmwareFlashException("${artifact.displayName} SHA-256 mismatch; refusing to flash")
+        }
+        return data
+    }
+}
+
+internal class G2FirmwareFlashException(message: String, cause: Throwable? = null) :
+    Exception(message, cause)
+
+/** Shared stock/CFW dual-lens OTA state machine. Rendering policy remains in [G2]. */
+@SuppressLint("MissingPermission")
+internal class G2Flasher {
+    companion object {
+        private const val BLOCK_SIZE = 4096
+        private const val BLOCK_NAK_RETRIES = 3
+        private const val COMPONENT_RETRIES = 3
+        private const val ACK_TIMEOUT_MS = 5_000L
+        private const val END_ACK_TIMEOUT_MS = 15_000L
+        private const val WRITE_RETRIES = 500
+        private const val WRITE_RETRY_MS = 2L
+        private const val ACCEPTED_WRITE_GAP_MS = 6L
+
+        fun preflight(image: ByteArray): G2FlashProtocol.ValidatedImage =
+            G2FlashProtocol.validateFirmware(image)
+    }
+
+    data class Target(
+        val label: String,
+        val gatt: BluetoothGatt,
+        val dataWrite: BluetoothGattCharacteristic,
+    )
+
+    private val running = AtomicBoolean(false)
+    private val receiveQueue = LinkedBlockingQueue<ByteArray>()
+    private var sequence = 0
+
+    val active: Boolean
+        get() = running.get()
+
+    fun receive(frame: ByteArray) {
+        if (active) receiveQueue.offer(frame.copyOf())
+    }
+
+    suspend fun flash(
+        context: Context,
+        artifact: G2FirmwareArtifact,
+        targets: List<Target>,
+    ): Map<String, Any> {
+        if (!running.compareAndSet(false, true)) {
+            throw G2FirmwareFlashException("A G2 firmware flash is already in progress.")
+        }
+        return try {
+            withContext(Dispatchers.IO) { run(context, artifact, targets) }
+        } catch (error: Throwable) {
+            progress(error.message ?: error.toString(), 0.0, done = true, ok = false)
+            throw error
+        } finally {
+            receiveQueue.clear()
+            running.set(false)
+        }
+    }
+
+    private fun run(
+        context: Context,
+        artifact: G2FirmwareArtifact,
+        targets: List<Target>,
+    ): Map<String, Any> {
+        progress("Validating bundled ${artifact.displayName}…", 0.02)
+        val image = G2FirmwareCatalog.load(context, artifact)
+        val validated =
+            try {
+                preflight(image)
+            } catch (error: Exception) {
+                throw G2FirmwareFlashException("EVENOTA validation failed: ${error.message}", error)
+            }
+
+        // Test the guard implementation itself against the byte-identical stock image before
+        // every flash, including CFW flashes.
+        val stock = G2FirmwareCatalog.load(context, G2FirmwareCatalog.artifacts.first())
+        G2FlashProtocol.selfTestGuard(stock, G2FlashProtocol.goldenStock)?.let { failure ->
+            throw G2FirmwareFlashException("Brick-guard self-test failed: $failure")
+        }
+        progress(
+            String.format("Image verified; program end 0x%08x", validated.guardResult.progEnd),
+            0.10,
+        )
+
+        if (targets.size != 2) {
+            throw G2FirmwareFlashException("Both G2 lenses must be connected before flashing.")
+        }
+        for ((lensIndex, target) in targets.withIndex()) {
+            progress("Flashing ${target.label} lens…", 0.12 + lensIndex * 0.43)
+            sequence = 0
+            flashLens(target, image, validated.segments, lensIndex)
+        }
+        progress("Flash complete.", 1.0, done = true, ok = true)
+        return mapOf(
+            "ok" to true,
+            "target" to artifact.id,
+            "version" to artifact.version,
+            "sha256" to artifact.sha256,
+        )
+    }
+
+    private fun flashLens(
+        target: Target,
+        image: ByteArray,
+        segments: List<G2FlashProtocol.Segment>,
+        lensIndex: Int,
+    ) {
+        drainReceiveQueue()
+        val beginStatus =
+            sendAndWait(
+                target,
+                G2FlashProtocol.ctrlFrames(0x00, seq = nextSequence()),
+                opcode = 0x00,
+            )
+        if (beginStatus !in setOf(0, 8, 9)) {
+            throw G2FirmwareFlashException(
+                "${target.label} lens rejected OTA begin (status $beginStatus)"
+            )
+        }
+        segments.forEachIndexed { index, segment ->
+            flashComponent(target, segment, index, segments.size, image, lensIndex)
+        }
+    }
+
+    private fun flashComponent(
+        target: Target,
+        segment: G2FlashProtocol.Segment,
+        index: Int,
+        total: Int,
+        image: ByteArray,
+        lensIndex: Int,
+    ) {
+        val offset = segment.off + 128
+        val end = offset + segment.ps
+        if (offset < 128 || segment.ps <= 0 || end > image.size.toLong()) {
+            throw G2FirmwareFlashException("${segment.fn} payload extends past EOF")
+        }
+        val payload = image.copyOfRange(offset.toInt(), end.toInt())
+        val blockCount = (payload.size + BLOCK_SIZE - 1) / BLOCK_SIZE
+        var lastFailure = "unknown error"
+
+        repeat(COMPONENT_RETRIES) { attemptIndex ->
+            val attempt = attemptIndex + 1
+            if (attempt > 1) {
+                progress(
+                    "${target.label}: retrying ${segment.fn} ($attempt/$COMPONENT_RETRIES)",
+                    0.0,
+                )
+                drainReceiveQueue()
+                Thread.sleep(1_500)
+            }
+            try {
+                val fileStatus =
+                    sendAndWait(
+                        target,
+                        G2FlashProtocol.ctrlFrames(0x01, segment.sub, seq = nextSequence()),
+                        opcode = 0x01,
+                    )
+                if (fileStatus != 0) throw G2FirmwareFlashException("FILE_CHECK status $fileStatus")
+
+                for (blockIndex in 0 until blockCount) {
+                    val start = blockIndex * BLOCK_SIZE
+                    val block = payload.copyOfRange(start, minOf(start + BLOCK_SIZE, payload.size))
+                    var acknowledged = false
+                    for (retryIndex in 0 until BLOCK_NAK_RETRIES) {
+                        val blockSequence = nextSequence()
+                        drainReceiveQueue()
+                        writeFrames(
+                            target,
+                            G2FlashProtocol.ctrlFrames(0x02, seq = blockSequence),
+                        )
+                        writeFrames(
+                            target,
+                            G2FlashProtocol.dataFrames(block, seq = blockSequence),
+                        )
+                        val status =
+                            try {
+                                waitForAck(0x02, ACK_TIMEOUT_MS)
+                            } catch (error: Exception) {
+                                // A timeout may mean the block committed and only its ACK was lost.
+                                // Never resend in place: restart the component from FILE_CHECK.
+                                throw G2FirmwareFlashException(
+                                    "${segment.fn} block ${blockIndex + 1}/$blockCount: ${error.message}",
+                                    error,
+                                )
+                            }
+                        if (status == 0) {
+                            acknowledged = true
+                            break
+                        }
+                        progress(
+                            "${target.label}: ${segment.fn} block ${blockIndex + 1}/$blockCount NAK $status, retry ${retryIndex + 1}/$BLOCK_NAK_RETRIES",
+                            0.0,
+                        )
+                    }
+                    if (!acknowledged) {
+                        throw G2FirmwareFlashException(
+                            "${segment.fn} block ${blockIndex + 1}/$blockCount was not acknowledged"
+                        )
+                    }
+                    val componentFraction =
+                        (index + (blockIndex + 1).toDouble() / blockCount) / total
+                    val fraction = 0.12 + lensIndex * 0.43 + componentFraction * 0.43
+                    progress(
+                        "${target.label}: ${segment.fn} ${blockIndex + 1}/$blockCount",
+                        fraction,
+                    )
+                }
+
+                val endStatus =
+                    sendAndWait(
+                        target,
+                        G2FlashProtocol.ctrlFrames(0x03, seq = nextSequence()),
+                        opcode = 0x03,
+                        timeoutMs = END_ACK_TIMEOUT_MS,
+                    )
+                if (endStatus !in setOf(0, 8, 9)) {
+                    throw G2FirmwareFlashException("END status $endStatus")
+                }
+                return
+            } catch (error: Exception) {
+                lastFailure = error.message ?: error.toString()
+            }
+        }
+        throw G2FirmwareFlashException(
+            "${target.label}: ${segment.fn} failed after $COMPONENT_RETRIES attempts: $lastFailure"
+        )
+    }
+
+    private fun sendAndWait(
+        target: Target,
+        frames: List<ByteArray>,
+        opcode: Int,
+        timeoutMs: Long = ACK_TIMEOUT_MS,
+    ): Int {
+        if (frames.isEmpty()) throw G2FirmwareFlashException("Cannot send an empty OTA frame set")
+        drainReceiveQueue()
+        writeFrames(target, frames)
+        return waitForAck(opcode, timeoutMs)
+    }
+
+    private fun waitForAck(opcode: Int, timeoutMs: Long): Int {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        val observed = ArrayDeque<String>()
+        while (System.currentTimeMillis() < deadline) {
+            val remaining = deadline - System.currentTimeMillis()
+            val frame = receiveQueue.poll(minOf(remaining, 200), TimeUnit.MILLISECONDS) ?: continue
+            G2FlashProtocol.otaAckStatus(listOf(frame), opcode)?.let { return it }
+            val parsed = G2FlashProtocol.parseRx(frame)
+            val detail =
+                if (parsed != null) {
+                    "seq=${parsed.sequence} sid=0x${parsed.sid.toString(16).padStart(2, '0')} pb=${parsed.pb.toHex()}"
+                } else {
+                    frame.take(16).toByteArray().toHex()
+                }
+            if (observed.size == 4) observed.removeFirst()
+            observed.addLast(detail)
+        }
+        val detail =
+            if (observed.isEmpty()) "no OTA notifications received" else observed.joinToString("; ")
+        throw G2FirmwareFlashException(
+            "Timed out waiting for OTA acknowledgement 0x${opcode.toString(16).padStart(2, '0')} ($detail)"
+        )
+    }
+
+    private fun writeFrames(target: Target, frames: List<ByteArray>) {
+        for (frame in frames) {
+            var written = false
+            for (attempt in 0 until WRITE_RETRIES) {
+                val status = writeFrame(target.gatt, target.dataWrite, frame)
+                if (status == 0) {
+                    written = true
+                    break
+                }
+                Thread.sleep(WRITE_RETRY_MS)
+            }
+            if (!written) throw G2FirmwareFlashException("BLE write backpressure did not clear")
+            Thread.sleep(ACCEPTED_WRITE_GAP_MS)
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun writeFrame(
+        gatt: BluetoothGatt,
+        characteristic: BluetoothGattCharacteristic,
+        frame: ByteArray,
+    ): Int =
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                gatt.writeCharacteristic(
+                    characteristic,
+                    frame,
+                    BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE,
+                )
+            } else {
+                characteristic.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+                characteristic.value = frame
+                if (gatt.writeCharacteristic(characteristic)) 0 else -1
+            }
+        } catch (error: SecurityException) {
+            throw G2FirmwareFlashException("BLE write permission was revoked", error)
+        }
+
+    private fun nextSequence(): Int {
+        sequence = (sequence + 1) and 0xFF
+        return sequence
+    }
+
+    private fun drainReceiveQueue() {
+        receiveQueue.clear()
+    }
+
+    private fun progress(message: String, progress: Double, done: Boolean = false, ok: Boolean = true) {
+        Bridge.log("G2 flash: $message")
+        Bridge.sendTypedMessage(
+            "g2_firmware_flash_progress",
+            mapOf(
+                "message" to message,
+                "progress" to progress.coerceIn(0.0, 1.0),
+                "done" to done,
+                "ok" to ok,
+            ),
+        )
+    }
+
+    private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it.toInt() and 0xFF) }
+}