@glassly/bluetooth-sdk 0.1.0-dev.100

package/android/src/main/java/com/glassly/bluetoothsdk/controllers/R1.kt

@@ -0,0 +1,1057 @@
+package com.glassly.bluetoothsdk.controllers
+
+import com.glassly.bluetoothsdk.PhotoRequest
+import android.Manifest
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.bluetooth.BluetoothGattDescriptor
+import android.bluetooth.le.BluetoothLeScanner
+import android.bluetooth.le.ScanCallback
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.core.content.ContextCompat
+import com.glassly.bluetoothsdk.Bridge
+import com.glassly.bluetoothsdk.DeviceManager
+import com.glassly.bluetoothsdk.DeviceStore
+import com.glassly.bluetoothsdk.utils.ControllerTypes
+import java.util.UUID
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+// MARK: - R1 BLE Constants
+
+private object R1BLE {
+    val SERVICE_UUID: UUID = UUID.fromString("BAE80001-4F05-4503-8E65-3AF1F7329D1F")
+    val WRITE_CHAR_1: UUID = UUID.fromString("BAE80010-4F05-4503-8E65-3AF1F7329D1F")
+    val NOTIFY_CHAR_1: UUID = UUID.fromString("BAE80011-4F05-4503-8E65-3AF1F7329D1F")
+    val WRITE_CHAR_2: UUID = UUID.fromString("BAE80012-4F05-4503-8E65-3AF1F7329D1F")
+    val NOTIFY_CHAR_2: UUID = UUID.fromString("BAE80013-4F05-4503-8E65-3AF1F7329D1F")
+    val BATTERY_SERVICE: UUID = UUID.fromString("0000180f-0000-1000-8000-00805f9b34fb")
+    val BATTERY_LEVEL_CHAR: UUID = UUID.fromString("00002a19-0000-1000-8000-00805f9b34fb")
+    val CCCD_UUID: UUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
+
+    val NAME_FILTERS = arrayOf("EVEN R1", "BCL60")
+
+    const val GESTURE_MARKER: Byte = 0xFF.toByte()
+}
+
+// MARK: - EUS transport encoder (phone → ring, channel 2)
+
+/**
+ * Recovered firmware contract (openCFW r1/ research): every phone→ring packet
+ * is a 12-byte "model" header
+ *   [version, module, moduleVersion, serial LE16, status, command, subcommand,
+ *    totalLength LE16, crc16 LE16]
+ * followed by the payload, where the phone-direction CRC-16 (CCITT rounds,
+ * init 0xFFFF) runs over the compact bytes [0,1,2,3,5,6,7,8,0x00] and then
+ * continues over the payload bytes. The model is carried on channel 2 inside a
+ * fragment train [sequence, crc32 LE32, ≤239 bytes]; the CRC-32 (poly
+ * 0x1EDC6F41, MSB-first, zero seed, no final xor) covers the whole model and
+ * sequence 0 terminates the train — all our packets fit a single fragment.
+ * Mirrors iOS R1.swift's R1Eus.
+ */
+private object R1Eus {
+    const val VERSION = 100
+    const val MODULE_SYSTEM = 0x01
+    const val MODULE_VERSION = 100
+    /** status bit 0x02 marks a SET; advStart requires it */
+    const val STATUS_SET = 0x02
+
+    /** system subcommand 0x08: payload [0x01] claims the phone role; the ring
+     *  requests link encryption/bonding in response */
+    const val SUBCMD_PAIR_AUTH = 0x08
+    /** system subcommand 0x0A: 12-byte payload = two 6-byte glasses arm MACs;
+     *  the ring stores both targets and fast-advertises for them */
+    const val SUBCMD_ADV_START = 0x0A
+
+    private fun crc16Step(crc: Int, byte: Int): Int {
+        var c = ((crc shr 8) or (crc shl 8)) and 0xFFFF
+        c = c xor (byte and 0xFF)
+        c = c xor ((c and 0x00FF) shr 4)
+        c = (c xor (c shl 12)) and 0xFFFF
+        c = (c xor ((c and 0x00FF) shl 5)) and 0xFFFF
+        return c
+    }
+
+    private fun phoneCrc16(header: ByteArray, payload: ByteArray): Int {
+        var crc = 0xFFFF
+        // compact header: bytes 0-3 and 5-8, then a zero placeholder
+        for (b in intArrayOf(
+            header[0].toInt(), header[1].toInt(), header[2].toInt(), header[3].toInt(),
+            header[5].toInt(), header[6].toInt(), header[7].toInt(), header[8].toInt(), 0
+        )) {
+            crc = crc16Step(crc, b)
+        }
+        for (b in payload) {
+            crc = crc16Step(crc, b.toInt())
+        }
+        return crc
+    }
+
+    private fun crc32(data: ByteArray): Long {
+        var crc = 0L
+        for (byte in data) {
+            crc = crc xor ((byte.toLong() and 0xFF) shl 24)
+            repeat(8) {
+                crc = if ((crc and 0x8000_0000L) != 0L) {
+                    ((crc shl 1) xor 0x1EDC6F41L) and 0xFFFF_FFFFL
+                } else {
+                    (crc shl 1) and 0xFFFF_FFFFL
+                }
+            }
+        }
+        return crc
+    }
+
+    /** Build one single-fragment system-module command packet. */
+    fun frame(subcommand: Int, status: Int, serial: Int, payload: ByteArray): ByteArray {
+        val length = 12 + payload.size
+        val header = byteArrayOf(
+            VERSION.toByte(), MODULE_SYSTEM.toByte(), MODULE_VERSION.toByte(),
+            (serial and 0xFF).toByte(), ((serial shr 8) and 0xFF).toByte(),
+            status.toByte(), 0x00, subcommand.toByte(),
+            (length and 0xFF).toByte(), ((length shr 8) and 0xFF).toByte(),
+            0, 0,
+        )
+        val crc16 = phoneCrc16(header, payload)
+        header[10] = (crc16 and 0xFF).toByte()
+        header[11] = ((crc16 shr 8) and 0xFF).toByte()
+        val model = header + payload
+
+        val outer = crc32(model)
+        return byteArrayOf(
+            0x00, // sequence 0: single-fragment train
+            (outer and 0xFF).toByte(),
+            ((outer shr 8) and 0xFF).toByte(),
+            ((outer shr 16) and 0xFF).toByte(),
+            ((outer shr 24) and 0xFF).toByte(),
+        ) + model
+    }
+}
+
+// MARK: - R1 Gesture Types
+
+private enum class R1Gesture(val rawValue: String) {
+    HOLD("hold"),
+    SINGLE_TAP("single_tap"),
+    DOUBLE_TAP("double_tap"),
+    SWIPE_UP("swipe_up"),
+    SWIPE_DOWN("swipe_down");
+
+    companion object {
+        /** Parse gesture from notification data: [0xFF, type, param] */
+        fun parse(data: ByteArray): R1Gesture? {
+            if (data.size < 3 || data[0] != R1BLE.GESTURE_MARKER) return null
+            return when (data[1]) {
+                0x03.toByte() -> HOLD
+                0x04.toByte() -> when (data[2]) {
+                    0x01.toByte() -> SINGLE_TAP
+                    0x02.toByte() -> DOUBLE_TAP
+                    else -> null
+                }
+                0x05.toByte() -> if ((data[2].toInt() and 0xFF) < 0x80) SWIPE_UP else SWIPE_DOWN
+                else -> null
+            }
+        }
+    }
+}
+
+// MARK: - R1 Controller
+
+class R1 : ControllerManager() {
+
+    // Connection state
+    private val appContext: Context = Bridge.getContext()
+    private val prefs = appContext.getSharedPreferences("r1_prefs", Context.MODE_PRIVATE)
+
+    private var bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()
+    private var scanner: BluetoothLeScanner? = null
+    private var scanCallback: ScanCallback? = null
+
+    private var ringGatt: BluetoothGatt? = null
+    private var isDisconnecting = false
+
+    // BLE characteristics
+    private var writeChar1: BluetoothGattCharacteristic? = null
+    private var notifyChar1: BluetoothGattCharacteristic? = null
+    private var writeChar2: BluetoothGattCharacteristic? = null
+    private var notifyChar2: BluetoothGattCharacteristic? = null
+    private var batteryLevelChar: BluetoothGattCharacteristic? = null
+    private var notifySubscriptionCount = 0
+    private var initSequenceRun = false
+
+    // Android serializes CCCD writes and reads — queue and drain in callbacks
+    private val pendingDescriptorWrites = ArrayDeque<BluetoothGattDescriptor>()
+    private val pendingReads = ArrayDeque<BluetoothGattCharacteristic>()
+    private var descriptorWriteInFlight = false
+    private var readInFlight = false
+
+    // Device search
+    private var deviceSearchId: String = "NOT_SET"
+
+    // BLE handle used by Android for reconnection (BluetoothDevice.address — may be a
+    // resolvable/random address depending on bonding state; not the ring's public MAC).
+    private var ringBleAddress: String?
+        get() = prefs.getString("r1_ringBleAddress", null)
+        set(value) {
+            prefs.edit().apply {
+                if (value == null) remove("r1_ringBleAddress") else putString("r1_ringBleAddress", value)
+                apply()
+            }
+        }
+
+    // Public ring MAC parsed from advertisement manufacturer data (last 6 bytes), formatted
+    // as "AA:BB:CC:DD:EE:FF". This is what gets published to DeviceStore/controllerMacAddress.
+    private var ringMacAddress: String?
+        get() = prefs.getString("r1_ringMacAddress", null)
+        set(value) {
+            prefs.edit().apply {
+                if (value == null) remove("r1_ringMacAddress") else putString("r1_ringMacAddress", value)
+                apply()
+            }
+        }
+
+    // peripheral name -> 6-byte ring MAC (hex string), populated from mfgData on every scan.
+    // Mirrors iOS ringMacAddressMap so reconnects re-validate freshness instead of trusting
+    // a stale stored MAC.
+    private fun loadRingMacAddressMap(): MutableMap<String, String> {
+        val raw = prefs.getString("r1_ringMacAddressMap", null) ?: return mutableMapOf()
+        val out = mutableMapOf<String, String>()
+        for (entry in raw.split(';')) {
+            if (entry.isEmpty()) continue
+            val idx = entry.indexOf('=')
+            if (idx <= 0) continue
+            out[entry.substring(0, idx)] = entry.substring(idx + 1)
+        }
+        return out
+    }
+
+    private fun saveRingMacAddressMap(map: Map<String, String>) {
+        val raw = map.entries.joinToString(";") { "${it.key}=${it.value}" }
+        prefs.edit().putString("r1_ringMacAddressMap", raw).apply()
+    }
+
+    private fun putRingMacInMap(name: String, mac: String) {
+        val map = loadRingMacAddressMap()
+        map[name] = mac
+        saveRingMacAddressMap(map)
+    }
+
+    private fun getRingMacFromMap(name: String): String? = loadRingMacAddressMap()[name]
+
+    // Reconnection
+    private val reconnectionManager = R1ReconnectionManager()
+
+    private fun startReconnectionTimer() {
+        reconnectionManager.start {
+            val connected = DeviceStore.get("glasses", "controllerConnected") as? Boolean ?: false
+            if (connected) {
+                true // already connected — stop retrying
+            } else {
+                Bridge.log("R1: Attempting reconnection...")
+                mainHandler.post { startScan() }
+                false // keep trying
+            }
+        }
+    }
+
+    // Battery
+    private var _batteryLevel: Int = -1
+        set(value) {
+            val old = field
+            field = value
+            if (value != old && value >= 0) {
+                DeviceStore.apply("glasses", "controllerBatteryLevel", value)
+            }
+        }
+
+    // Heartbeat
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var heartbeatRunnable: Runnable? = null
+
+    init {
+        type = ControllerTypes.R1
+        hasMic = false
+    }
+
+    // MARK: - Permissions
+
+    private fun hasScanPermission(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return true
+        return ContextCompat.checkSelfPermission(
+            appContext, Manifest.permission.BLUETOOTH_SCAN
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun hasConnectPermission(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return true
+        return ContextCompat.checkSelfPermission(
+            appContext, Manifest.permission.BLUETOOTH_CONNECT
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    // MARK: - BLE Scanning
+
+    private fun startScan(): Boolean {
+        Bridge.log("R1: startScan()")
+        val adapter = bluetoothAdapter ?: BluetoothAdapter.getDefaultAdapter().also { bluetoothAdapter = it }
+        if (adapter == null) {
+            Bridge.log("R1: No Bluetooth adapter")
+            return false
+        }
+        if (!adapter.isEnabled) {
+            Bridge.log("R1: Bluetooth not powered on")
+            return false
+        }
+        if (!hasScanPermission() || !hasConnectPermission()) {
+            Bridge.log("R1: Missing Bluetooth permissions")
+            return false
+        }
+
+        // Already connected — don't start a new scan
+        if (ringGatt != null) {
+            Bridge.log("R1: Already connected, skipping scan")
+            return true
+        }
+
+        isDisconnecting = false
+
+        // Stop any prior scan before starting a new one (avoids leaking ScanCallback)
+        stopScan()
+
+        // Try address-based reconnection first
+        if (connectByBleAddress()) {
+            return true
+        }
+
+        val s = adapter.bluetoothLeScanner
+        if (s == null) {
+            Bridge.log("R1: BluetoothLeScanner not available")
+            return false
+        }
+        scanner = s
+
+        val cb = object : ScanCallback() {
+            override fun onScanResult(callbackType: Int, result: ScanResult?) {
+                if (result == null) return
+                handleScanResult(result)
+            }
+
+            override fun onScanFailed(errorCode: Int) {
+                Bridge.log("R1: Scan failed: $errorCode")
+            }
+        }
+        scanCallback = cb
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+            .build()
+        try {
+            s.startScan(null, settings, cb)
+        } catch (e: SecurityException) {
+            Bridge.log("R1: startScan SecurityException: ${e.message}")
+            return false
+        }
+        return true
+    }
+
+    override fun stopScan() {
+        val s = scanner ?: return
+        val cb = scanCallback ?: return
+        try {
+            s.stopScan(cb)
+        } catch (e: SecurityException) {
+            Bridge.log("R1: stopScan SecurityException: ${e.message}")
+        }
+        scanCallback = null
+    }
+
+    private fun connectByBleAddress(): Boolean {
+        if (deviceSearchId == "NOT_SET" || deviceSearchId.isEmpty()) {
+            Bridge.log("R1: No deviceSearchId set, skipping connect by address")
+            return false
+        }
+        val address = ringBleAddress ?: return false
+        val adapter = bluetoothAdapter ?: return false
+        if (ringGatt != null) {
+            Bridge.log("R1: connectByBleAddress skipped — already connected")
+            return true
+        }
+        val device = try {
+            adapter.getRemoteDevice(address)
+        } catch (e: IllegalArgumentException) {
+            Bridge.log("R1: Invalid stored BLE address: $address")
+            return false
+        }
+        try {
+            ringGatt = device.connectGatt(appContext, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+            Bridge.log("R1: Reconnecting by address to ${device.name ?: address}")
+        } catch (e: SecurityException) {
+            Bridge.log("R1: connectGatt SecurityException: ${e.message}")
+            return false
+        }
+        return true
+    }
+
+    private fun matchesNameFilter(name: String?): Boolean {
+        if (name == null) return false
+        return R1BLE.NAME_FILTERS.any { name.contains(it) }
+    }
+
+    /** Extract a device identifier from the ring name (e.g. "EVEN R1_CEC5BA" -> "CEC5BA") */
+    private fun extractRingId(name: String): String? {
+        val idx = name.indexOf("R1_")
+        if (idx < 0) return null
+        val id = name.substring(idx + 3)
+        return if (id.isEmpty()) null else id
+    }
+
+    private fun handleScanResult(result: ScanResult) {
+        val device = result.device ?: return
+        val advertisedName = result.scanRecord?.deviceName
+        val deviceName: String? = try {
+            device.name ?: advertisedName
+        } catch (e: SecurityException) {
+            advertisedName
+        }
+        mainHandler.post {
+            // Already connected — ignore further scan results
+            if (ringGatt != null) {
+                stopScan()
+                return@post
+            }
+            if (!matchesNameFilter(deviceName)) return@post
+
+            val mfgMap = result.scanRecord?.manufacturerSpecificData
+            val mfgBytes: ByteArray? = if (mfgMap != null && mfgMap.size() > 0) mfgMap.valueAt(0) else null
+            val mfgHex = mfgBytes?.joinToString(" ") { String.format("%02X", it) } ?: "none"
+            Bridge.log("R1: Discovered: ${deviceName ?: "?"} (RSSI: ${result.rssi}) mfgData: $mfgHex")
+
+            // Extract ring MAC from manufacturer data (last 6 bytes) and store name->MAC map.
+            // Android's manufacturerSpecificData strips the 2-byte company ID; iOS keeps it. The
+            // resulting "last 6 bytes" land in reversed byte order between platforms (verified in
+            // the field), so reverse here to match iOS's stored string ("1B:08:26:8E:0E:E6").
+            if (deviceName != null && mfgBytes != null && mfgBytes.size >= 6) {
+                val tail = mfgBytes.copyOfRange(mfgBytes.size - 6, mfgBytes.size)
+                val macStr = tail.joinToString(":") { String.format("%02X", it) }
+                putRingMacInMap(deviceName, macStr)
+            }
+
+            // Emit discovered device
+            val id = deviceName?.let { extractRingId(it) }
+            if (id != null) {
+                Bridge.sendDiscoveredDevice(ControllerTypes.R1, id)
+            }
+
+            // Scan-only mode: don't auto-connect
+            if (deviceSearchId == "NOT_SET") return@post
+
+            // If search ID is specific, check it matches
+            val name = deviceName ?: return@post
+            val parsedId = extractRingId(name)
+            if (parsedId != deviceSearchId && !name.contains(deviceSearchId)) return@post
+
+            if (ringGatt == null) {
+                ringBleAddress = device.address
+                try {
+                    ringGatt = device.connectGatt(appContext, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+                } catch (e: SecurityException) {
+                    Bridge.log("R1: connectGatt SecurityException: ${e.message}")
+                    return@post
+                }
+                stopScan()
+                Bridge.log("R1: Connecting to ${name}")
+            }
+        }
+    }
+
+    // MARK: - EUS commands
+
+    private var eusSerial = 0
+
+    private fun nextEusSerial(): Int {
+        eusSerial = (eusSerial + 1) and 0xFFFF
+        if (eusSerial == 0) eusSerial = 1
+        return eusSerial
+    }
+
+    /**
+     * EUS system commands go to WRITE_CHAR_2 only — channel 2 is the framed
+     * transport; channel 1 speaks the separate legacy protocol.
+     */
+    private fun sendEusCommand(subcommand: Int, payload: ByteArray, log: String) {
+        val wc = writeChar2
+        if (wc == null) {
+            Bridge.log("R1: $log: no channel-2 write characteristic")
+            return
+        }
+        val packet = R1Eus.frame(subcommand, R1Eus.STATUS_SET, nextEusSerial(), payload)
+        writeNoResponse(wc, packet)
+        Bridge.log("R1: $log sent (${packet.size} bytes)")
+    }
+
+    // MARK: - Init Sequence
+
+    /**
+     * Runs after notify subscriptions are confirmed: claim the phone role,
+     * then mark the phone link ready.
+     */
+    private fun runInitSequence() {
+        if (initSequenceRun) return
+        initSequenceRun = true
+
+        Bridge.log("R1: Running init sequence")
+
+        if (writeChar2 == null) {
+            Bridge.log("R1: No channel-2 write characteristic, skipping init")
+            markConnected()
+            return
+        }
+
+        sendEusCommand(R1Eus.SUBCMD_PAIR_AUTH, byteArrayOf(0x01), "pairAuth")
+
+        mainHandler.postDelayed({ markConnected() }, 300)
+    }
+
+    private fun writeNoResponse(char: BluetoothGattCharacteristic, data: ByteArray) {
+        char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+        char.value = data
+        try {
+            ringGatt?.writeCharacteristic(char)
+        } catch (e: SecurityException) {
+            Bridge.log("R1: writeCharacteristic SecurityException: ${e.message}")
+        }
+    }
+
+    private fun markConnected() {
+        reconnectionManager.stop()
+        Bridge.log("R1: Ring connected")
+
+        val gatt = ringGatt
+        val connectedName = try { gatt?.device?.name } catch (e: SecurityException) { null }
+        if (connectedName != null) {
+            extractRingId(connectedName)?.let {
+                DeviceStore.apply("bluetooth", "controller_device_name", it)
+            }
+        }
+
+        val mac = ringMacAddress
+        if (mac == null) {
+            Bridge.log("R1: No ring MAC address found")
+            return
+        }
+        DeviceStore.apply("glasses", "controllerMacAddress", mac)
+        DeviceStore.apply("glasses", "controllerConnected", true)
+        // The phone link owns these flags: a ready phone link IS pairing
+        // success (fires handleControllerReady). The glasses link is layered
+        // on afterwards via advStart + RING_CONNECT_INFO.
+        DeviceStore.apply("glasses", "controllerFullyBooted", true)
+
+        // tell the ring to connect to the glasses if we have its mac address:
+        connectToGlasses()
+
+        // after a second, connect the glasses to the controller if needed:
+        CoroutineScope(Dispatchers.Main).launch {
+            delay(1000)
+            DeviceManager.getInstance().sgc?.connectController()
+        }
+
+        startHeartbeat()
+    }
+
+    /**
+     * Tells the ring which glasses may connect to it: EUS advStart whose
+     * 12-byte payload is the two glasses arm MACs. The ring stores both
+     * targets, fast-advertises while a glasses role is open, and accepts a
+     * connection from either arm. With only one arm MAC known it is sent for
+     * both targets — the ring matches against either slot.
+     */
+    private fun connectToGlasses() {
+        fun stored(key: String): String? =
+            (DeviceStore.get("glasses", key) as? String)?.takeIf { it.isNotEmpty() }
+
+        val left = stored("leftMacAddress")
+            ?: stored("bluetoothMacAddress")
+            ?: prefs.getString("glasses_btMacAddress", null)
+        val right = stored("rightMacAddress")
+            ?: prefs.getString("glasses_btMacAddressRight", null)
+
+        if (left == null) {
+            Bridge.log("R1: connectToGlasses: no glasses MAC")
+            return
+        }
+        val leftBytes = parseMac(left)
+        if (leftBytes == null) {
+            Bridge.log("R1: connectToGlasses: could not parse glasses MAC")
+            return
+        }
+        val rightBytes = right?.let { parseMac(it) } ?: leftBytes
+
+        // Cache so we can re-send even before the glasses are next scanned.
+        prefs.edit().apply {
+            putString("glasses_btMacAddress", left)
+            if (right != null) putString("glasses_btMacAddressRight", right)
+            apply()
+        }
+
+        sendEusCommand(R1Eus.SUBCMD_ADV_START, leftBytes + rightBytes, "advStart")
+    }
+
+    /** Parse "AA:BB:CC:DD:EE:FF" or "AABBCCDDEEFF" into 6 raw bytes. */
+    private fun parseMac(s: String): ByteArray? {
+        val cleaned = s.replace(":", "").replace("-", "")
+        if (cleaned.length != 12) return null
+        val out = ByteArray(6)
+        for (i in 0 until 6) {
+            val byte = cleaned.substring(i * 2, i * 2 + 2).toIntOrNull(16) ?: return null
+            out[i] = byte.toByte()
+        }
+        return out
+    }
+
+    // MARK: - Heartbeat
+
+    private fun startHeartbeat() {
+        stopHeartbeat()
+        val r = object : Runnable {
+            override fun run() {
+                mainHandler.postDelayed(this, 30_000L)
+                val isConnected = DeviceStore.get("glasses", "controllerConnected") as? Boolean ?: false
+                if (!isConnected) return
+                val char = batteryLevelChar
+                if (char != null) {
+                    try {
+                        ringGatt?.readCharacteristic(char)
+                    } catch (e: SecurityException) {
+                        Bridge.log("R1: heartbeat read SecurityException: ${e.message}")
+                    }
+                }
+            }
+        }
+        heartbeatRunnable = r
+        mainHandler.postDelayed(r, 30_000L)
+    }
+
+    private fun stopHeartbeat() {
+        heartbeatRunnable?.let { mainHandler.removeCallbacks(it) }
+        heartbeatRunnable = null
+    }
+
+    // MARK: - Incoming Data Handling
+
+    private fun handleNotification(characteristic: BluetoothGattCharacteristic, data: ByteArray) {
+        val hex = data.joinToString(" ") { String.format("%02X", it) }
+        val shortUuid = characteristic.uuid.toString().takeLast(4)
+        Bridge.log("R1: $shortUuid -> $hex")
+
+        val timestamp = System.currentTimeMillis()
+
+        // Gesture: [0xFF, type, param]
+        if (data.size >= 3 && data[0] == R1BLE.GESTURE_MARKER) {
+            val gesture = R1Gesture.parse(data)
+            if (gesture != null) {
+                Bridge.log("R1: Gesture: ${gesture.rawValue}")
+                Bridge.sendTouchEvent(ControllerTypes.R1, gesture.rawValue, timestamp)
+            } else {
+                Bridge.log(
+                    "R1: Unknown gesture type=0x%02X param=0x%02X".format(data[1], data[2])
+                )
+            }
+            return
+        }
+
+        // Battery: 2 bytes, first byte is percentage
+        if (data.size == 2 && (data[0].toInt() and 0xFF) <= 100) {
+            _batteryLevel = data[0].toInt() and 0xFF
+            Bridge.log("R1: Battery: ${_batteryLevel}%")
+            return
+        }
+
+        // State: single byte (0x01=ready, 0x00=menu)
+        if (data.size == 1) {
+            val state = when (data[0]) {
+                0x01.toByte() -> "ready"
+                0x00.toByte() -> "menu"
+                else -> "unknown(${data[0].toInt() and 0xFF})"
+            }
+            Bridge.log("R1: State: $state")
+            return
+        }
+
+        // Longer data: check for embedded gesture marker
+        if (data.size > 3) {
+            val ffIndex = data.indexOfFirst { it == R1BLE.GESTURE_MARKER }
+            if (ffIndex >= 0 && ffIndex + 2 < data.size) {
+                val slice = byteArrayOf(data[ffIndex], data[ffIndex + 1], data[ffIndex + 2])
+                val gesture = R1Gesture.parse(slice)
+                if (gesture != null) {
+                    Bridge.log("R1: Embedded gesture: ${gesture.rawValue}")
+                    Bridge.sendTouchEvent(ControllerTypes.R1, gesture.rawValue, timestamp)
+                    return
+                }
+            }
+        }
+    }
+
+    // MARK: - Connection State Reset
+
+    private fun resetConnectionState() {
+        ringGatt = null
+        writeChar1 = null
+        notifyChar1 = null
+        writeChar2 = null
+        notifyChar2 = null
+        batteryLevelChar = null
+        notifySubscriptionCount = 0
+        initSequenceRun = false
+        pendingDescriptorWrites.clear()
+        pendingReads.clear()
+        descriptorWriteInFlight = false
+        readInFlight = false
+        // ringMacAddress/ringBleAddress persist across disconnects so
+        // reconnection can find the ring again; only forget() clears them.
+        DeviceStore.apply("glasses", "controllerConnected", false)
+        DeviceStore.apply("glasses", "controllerFullyBooted", false)
+    }
+
+    // MARK: - GATT Callback
+
+    private val gattCallback = object : BluetoothGattCallback() {
+        override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
+            when (newState) {
+                BluetoothGatt.STATE_CONNECTED -> {
+                    val name = try { gatt.device.name } catch (e: SecurityException) { null }
+                    Bridge.log("R1: Connected to ${name ?: "ring"}")
+
+                    // Validate against the name->MAC map populated during scan. If the connected
+                    // peripheral isn't in the map we don't have its true public MAC — drop the
+                    // connection and rescan rather than publishing a stale/wrong MAC. Mirrors
+                    // iOS R1.swift didConnect.
+                    val mappedMac = name?.let { getRingMacFromMap(it) }
+                    if (mappedMac == null) {
+                        Bridge.log("R1: No MAC stored in map found for ${name ?: "ring"}")
+                        mainHandler.post {
+                            disconnect()
+                            ringBleAddress = null
+                            DeviceStore.apply("glasses", "controllerConnected", false)
+                            DeviceStore.apply("glasses", "controllerFullyBooted", false)
+                            DeviceStore.apply("glasses", "controllerSearching", true)
+                            mainHandler.postDelayed({ startScan() }, 1000)
+                        }
+                        return
+                    }
+                    ringMacAddress = mappedMac
+
+                    try {
+                        gatt.discoverServices()
+                    } catch (e: SecurityException) {
+                        Bridge.log("R1: discoverServices SecurityException: ${e.message}")
+                    }
+                }
+                BluetoothGatt.STATE_DISCONNECTED -> {
+                    Bridge.log("R1: Disconnected (status=$status)")
+                    mainHandler.post {
+                        stopHeartbeat()
+                        try { gatt.close() } catch (e: SecurityException) {}
+                        if (isDisconnecting) return@post
+                        resetConnectionState()
+                        startReconnectionTimer()
+                    }
+                }
+            }
+        }
+
+        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Bridge.log("R1: onServicesDiscovered status=$status")
+                return
+            }
+            mainHandler.post {
+                val services = gatt.services ?: return@post
+                for (service in services) {
+                    for (char in service.characteristics) {
+                        Bridge.log("R1: char discovered: ${char.uuid}")
+                        val props = char.properties
+                        val propStr = buildList {
+                            if (props and BluetoothGattCharacteristic.PROPERTY_READ != 0) add("read")
+                            if (props and BluetoothGattCharacteristic.PROPERTY_WRITE != 0) add("write")
+                            if (props and BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE != 0) add("writeNoResp")
+                            if (props and BluetoothGattCharacteristic.PROPERTY_NOTIFY != 0) add("notify")
+                            if (props and BluetoothGattCharacteristic.PROPERTY_INDICATE != 0) add("indicate")
+                        }.joinToString(",")
+                        Bridge.log("R1: char ${char.uuid} props=[$propStr]")
+
+                        // Store known characteristics
+                        when (char.uuid) {
+                            R1BLE.WRITE_CHAR_1 -> writeChar1 = char
+                            R1BLE.NOTIFY_CHAR_1 -> notifyChar1 = char
+                            R1BLE.WRITE_CHAR_2 -> writeChar2 = char
+                            R1BLE.NOTIFY_CHAR_2 -> notifyChar2 = char
+                            R1BLE.BATTERY_LEVEL_CHAR -> batteryLevelChar = char
+                        }
+
+                        // Subscribe to any notify/indicate characteristic
+                        val notifyEligible = props and BluetoothGattCharacteristic.PROPERTY_NOTIFY != 0
+                        val indicateEligible = props and BluetoothGattCharacteristic.PROPERTY_INDICATE != 0
+                        if (notifyEligible || indicateEligible) {
+                            try {
+                                gatt.setCharacteristicNotification(char, true)
+                            } catch (e: SecurityException) {
+                                Bridge.log("R1: setCharacteristicNotification SecurityException: ${e.message}")
+                            }
+                            val descriptor = char.getDescriptor(R1BLE.CCCD_UUID)
+                            if (descriptor != null) {
+                                descriptor.value = if (notifyEligible) {
+                                    BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+                                } else {
+                                    BluetoothGattDescriptor.ENABLE_INDICATION_VALUE
+                                }
+                                pendingDescriptorWrites.addLast(descriptor)
+                            }
+                        }
+
+                        // Queue reads (run after CCCD queue drains)
+                        if (props and BluetoothGattCharacteristic.PROPERTY_READ != 0) {
+                            pendingReads.addLast(char)
+                        }
+                    }
+                }
+                drainDescriptorQueue(gatt)
+            }
+        }
+
+        override fun onDescriptorWrite(
+            gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int
+        ) {
+            mainHandler.post {
+                descriptorWriteInFlight = false
+                if (status != BluetoothGatt.GATT_SUCCESS) {
+                    Bridge.log("R1: Descriptor write failed: $status on ${descriptor.characteristic.uuid}")
+                } else {
+                    Bridge.log("R1: Notify enabled on ${descriptor.characteristic.uuid}")
+                    notifySubscriptionCount += 1
+                    if (notifySubscriptionCount >= 2 && !initSequenceRun) {
+                        mainHandler.postDelayed({ runInitSequence() }, 300)
+                    }
+                }
+                drainDescriptorQueue(gatt)
+            }
+        }
+
+        override fun onCharacteristicChanged(
+            gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic
+        ) {
+            val data = characteristic.value ?: return
+            if (data.isEmpty()) return
+            mainHandler.post { handleNotification(characteristic, data) }
+        }
+
+        override fun onCharacteristicRead(
+            gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int
+        ) {
+            val data = characteristic.value
+            mainHandler.post {
+                readInFlight = false
+                if (status == BluetoothGatt.GATT_SUCCESS && data != null && data.isNotEmpty()) {
+                    if (characteristic.uuid == R1BLE.BATTERY_LEVEL_CHAR) {
+                        _batteryLevel = data[0].toInt() and 0xFF
+                        Bridge.log("R1: Battery (std): ${_batteryLevel}%")
+                    } else {
+                        handleNotification(characteristic, data)
+                    }
+                }
+                drainReadQueue(gatt)
+            }
+        }
+
+        override fun onCharacteristicWrite(
+            gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int
+        ) {
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Bridge.log("R1: Write error on ${characteristic.uuid}: $status")
+            }
+        }
+    }
+
+    private fun drainDescriptorQueue(gatt: BluetoothGatt) {
+        if (descriptorWriteInFlight) return
+        val next = pendingDescriptorWrites.removeFirstOrNull()
+        if (next == null) {
+            // Once CCCD queue drained, start reads
+            drainReadQueue(gatt)
+            return
+        }
+        descriptorWriteInFlight = true
+        try {
+            gatt.writeDescriptor(next)
+        } catch (e: SecurityException) {
+            descriptorWriteInFlight = false
+            Bridge.log("R1: writeDescriptor SecurityException: ${e.message}")
+            drainDescriptorQueue(gatt)
+        }
+    }
+
+    private fun drainReadQueue(gatt: BluetoothGatt) {
+        if (readInFlight) return
+        val next = pendingReads.removeFirstOrNull() ?: return
+        readInFlight = true
+        try {
+            gatt.readCharacteristic(next)
+        } catch (e: SecurityException) {
+            readInFlight = false
+            Bridge.log("R1: readCharacteristic SecurityException: ${e.message}")
+            drainReadQueue(gatt)
+        }
+    }
+
+    // MARK: - ControllerManager overrides
+
+    override fun findCompatibleDevices() {
+        Bridge.log("R1: findCompatibleDevices()")
+        deviceSearchId = "NOT_SET"
+        startScan()
+    }
+
+    override fun connectById(id: String) {
+        Bridge.log("R1: connectById($id)")
+        deviceSearchId = id
+        startScan()
+    }
+
+    override fun disconnect() {
+        Bridge.log("R1: disconnect()")
+        isDisconnecting = true
+        stopHeartbeat()
+        reconnectionManager.stop()
+        try {
+            ringGatt?.disconnect()
+            ringGatt?.close()
+        } catch (e: SecurityException) {
+            Bridge.log("R1: disconnect SecurityException: ${e.message}")
+        }
+        resetConnectionState()
+    }
+
+    override fun forget() {
+        disconnect()
+        ringMacAddress = null
+        ringBleAddress = null
+        prefs.edit().remove("r1_ringMacAddressMap").apply()
+        deviceSearchId = "NOT_SET"
+    }
+
+    override fun cleanup() {
+        disconnect()
+    }
+
+    override fun getConnectedBluetoothName(): String? {
+        return try { ringGatt?.device?.name } catch (e: SecurityException) { null }
+    }
+
+    override fun ping() {
+        val char = batteryLevelChar ?: return
+        try {
+            ringGatt?.readCharacteristic(char)
+        } catch (e: SecurityException) {
+            Bridge.log("R1: ping SecurityException: ${e.message}")
+        }
+    }
+
+    override fun getBatteryStatus() {
+        val char = batteryLevelChar ?: return
+        try {
+            ringGatt?.readCharacteristic(char)
+        } catch (e: SecurityException) {
+            Bridge.log("R1: getBatteryStatus SecurityException: ${e.message}")
+        }
+    }
+
+    // MARK: - No-op implementations (ring has no display/camera/wifi/mic)
+
+    override fun sendIncidentId(incidentId: String) {}
+    override fun setMicEnabled(enabled: Boolean) {}
+    override fun sortMicRanking(list: MutableList<String>): MutableList<String> = list
+    override fun sendJson(jsonOriginal: Map<String, Any>, wakeUp: Boolean, requireAck: Boolean) {}
+    override fun requestPhoto(request: PhotoRequest) {}
+    override fun startVideoRecording(requestId: String, save: Boolean, sound: Boolean) {}
+    override fun stopVideoRecording(requestId: String) {}
+    override fun startStream(message: Map<String, Any>) {}
+    override fun stopStream() {}
+    override fun sendStreamKeepAlive(message: Map<String, Any>) {}
+    override fun sendButtonPhotoSettings() {}
+    override fun sendButtonVideoRecordingSettings() {}
+    override fun sendButtonMaxRecordingTime() {}
+    override fun setBrightness(level: Int, autoMode: Boolean) {}
+    override fun clearDisplay() {}
+    override fun sendTextWall(text: String) {}
+    override fun sendDoubleTextWall(top: String, bottom: String) {}
+    override fun displayBitmap(
+            base64ImageData: String,
+            x: Int?,
+            y: Int?,
+            width: Int?,
+            height: Int?
+    ): Boolean = false
+    override fun showDashboard() {}
+    override fun setDashboardPosition(height: Int, depth: Int) {}
+    override fun setHeadUpAngle(angle: Int) {}
+    override fun setSilentMode(enabled: Boolean) {}
+    override fun exit() {}
+    override fun sendShutdown() { disconnect() }
+    override fun sendReboot() {}
+    override fun sendRgbLedControl(
+        requestId: String, packageName: String?, action: String, color: String?,
+        onDurationMs: Int, offDurationMs: Int, count: Int
+    ) {}
+    override fun requestWifiScan() {}
+    override fun sendWifiCredentials(ssid: String, password: String) {}
+    override fun forgetWifiNetwork(ssid: String) {}
+    override fun sendHotspotState(enabled: Boolean) {}
+    override fun sendOtaStart(otaVersionUrl: String?) {}
+    override fun sendUserEmailToGlasses(email: String) {}
+    override fun queryGalleryStatus() {}
+    override fun sendGalleryMode() {}
+    override fun requestVersionInfo() {}
+}
+
+// MARK: - R1 Reconnection Manager
+// Coroutine-based port of Swift's R1ReconnectionManager actor.
+
+private class R1ReconnectionManager(
+    private val intervalSeconds: Long = 30L,
+    private val maxAttempts: Int = -1
+) {
+    private var job: Job? = null
+    private var attempts = 0
+
+    fun start(onAttempt: suspend () -> Boolean) {
+        stop()
+        attempts = 0
+        job = CoroutineScope(Dispatchers.Default).launch {
+            while (isActive) {
+                delay(intervalSeconds * 1_000L)
+                if (!isActive) break
+                attempts += 1
+                if (maxAttempts > 0 && attempts > maxAttempts) break
+                if (onAttempt()) break
+            }
+        }
+    }
+
+    fun stop() {
+        job?.cancel()
+        job = null
+        attempts = 0
+    }
+}