@glassly/bluetooth-sdk 0.1.0-dev.99 → 0.2.8-dev.444

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

@@ -0,0 +1,181 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import com.glassly.bluetoothsdk.AllowedApp
+import com.glassly.bluetoothsdk.PhoneNotificationUpload
+import java.io.ByteArrayOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Wire format for the G2 file-transfer pushes (0xC4/0xC5 services). Pure so the
+ * header layout, CRC variant and JSON shape stay unit-testable.
+ */
+object G2NotificationFile {
+    /** The firmware dispatches on the header's file type, not the filename or JSON. */
+    const val FILENAME = "user/notify_whitelist.json"
+
+    /**
+     * eEvenFileServiceType from the stock app's efs_transmit.proto. A file typed
+     * as a notification whose JSON has no `android_notification` node leaves a
+     * blank card in the stock viewer.
+     */
+    const val FILE_TYPE_WHITELIST = 0 // NOTIFICATION_JSON_WHITELIST
+    const val FILE_TYPE_NOTIFICATION = 1 // ANDROID_MSG_JSON_NOTIFICATION
+
+    const val HEADER_SIZE = 93
+    private const val FILENAME_FIELD_SIZE = 80
+
+    /** Firmware caps: 100-app list, 64-byte id and 16-byte name records incl. NUL. */
+    const val MAX_APPS = 100
+    const val MAX_IDENTIFIER_BYTES = 63
+    const val MAX_DISPLAY_NAME_BYTES = 15
+
+    const val MAX_TITLE_BYTES = 120
+    const val MAX_SUBTITLE_BYTES = 120
+    const val MAX_MESSAGE_BYTES = 512
+
+    /** Notification action id the firmware reads as "show this now". */
+    private const val ACTION_SHOW = 0
+
+    // CRC-32C (Castagnoli), init 0, non-reflected (MSB-first) — the FILE_CHECK
+    // variant, NOT the common reflected crc32c.
+    private const val POLYNOMIAL = 0x1EDC6F41L
+
+    private val crcTable: IntArray =
+        IntArray(256) { index ->
+            var crc = index.toLong() shl 24
+            repeat(8) {
+                crc = if (crc and 0x80000000L != 0L) ((crc shl 1) xor POLYNOMIAL) else (crc shl 1)
+                crc = crc and 0xFFFFFFFFL
+            }
+            crc.toInt()
+        }
+
+    fun crc32c(bytes: ByteArray): Int {
+        var crc = 0
+        for (byte in bytes) {
+            val index = ((crc ushr 24) xor (byte.toInt() and 0xFF)) and 0xFF
+            crc = (crc shl 8) xor crcTable[index]
+        }
+        return crc
+    }
+
+    /**
+     * 93-byte FILE_CHECK payload as the firmware reads it: SEND_START command
+     * byte, then u32 file type, u32 size, u32 CRC-32C and the NUL-padded
+     * filename. (The even-g2-protocol docs describe the same bytes shifted by
+     * one — "mode 0x100, size * 256, crc shl 8, extra" — which hides that
+     * "mode 0x100" is file type 1, the Android notification.)
+     */
+    fun fileCheckHeader(filename: String, content: ByteArray, fileType: Int): ByteArray {
+        val crc = crc32c(content)
+        val out = ByteArrayOutputStream(HEADER_SIZE)
+        out.write(0x00) // eEvenFileSendServiceCID SEND_START
+        writeLittleEndian(out, fileType)
+        writeLittleEndian(out, content.size)
+        writeLittleEndian(out, crc)
+        var name = filename.toByteArray(Charsets.UTF_8)
+        if (name.size > FILENAME_FIELD_SIZE) {
+            name = name.copyOfRange(0, FILENAME_FIELD_SIZE)
+        }
+        out.write(name)
+        out.write(ByteArray(FILENAME_FIELD_SIZE - name.size))
+        return out.toByteArray()
+    }
+
+    /**
+     * Allowlist file in the stock app's shape. Ids over
+     * [MAX_IDENTIFIER_BYTES] are invalid to the firmware and dropped; names
+     * truncate. Key order is fixed — the glasses cache by checksum.
+     */
+    fun whitelistJson(filterEnabled: Boolean, apps: List<AllowedApp>): ByteArray {
+        val entries = StringBuilder()
+        var count = 0
+        for (app in apps) {
+            if (count >= MAX_APPS) break
+            if (app.id.isEmpty()) continue
+            if (app.id.toByteArray(Charsets.UTF_8).size > MAX_IDENTIFIER_BYTES) continue
+            val name = app.name.ifEmpty { app.id }
+            if (count > 0) entries.append(',')
+            entries.append("{\"id\":").append(quote(app.id))
+            entries.append(",\"name\":").append(quote(truncateUtf8(name, MAX_DISPLAY_NAME_BYTES))).append('}')
+            count++
+        }
+        val json = StringBuilder()
+        json.append("{\"app\":{\"enable\":").append(filterEnabled)
+        json.append(",\"list\":[").append(entries).append("]}")
+        json.append(",\"calendar_enable\":true")
+        json.append(",\"call_enable\":true")
+        json.append(",\"ios_mail_enable\":true")
+        json.append(",\"msg_enable\":true}")
+        return json.toString().toByteArray(Charsets.UTF_8)
+    }
+
+    /**
+     * Notification content for the firmware to present and keep in history.
+     * `date` is the phone's local wall clock; `time_s` is the epoch second.
+     */
+    fun notificationJson(upload: PhoneNotificationUpload, msgId: Int, nowMs: Long): ByteArray {
+        val timestampMs = if (upload.timestampMs > 0) upload.timestampMs else nowMs
+        val formatter = SimpleDateFormat("yyyyMMdd'T'HHmmss", Locale.US)
+        val json = StringBuilder()
+        json.append("{\"android_notification\":{")
+        json.append("\"action\":").append(ACTION_SHOW)
+        json.append(",\"app_identifier\":").append(quote(upload.packageName.trim()))
+        json.append(",\"date\":").append(quote(formatter.format(Date(timestampMs))))
+        json.append(",\"display_name\":")
+            .append(quote(truncateUtf8(upload.appName.trim().ifEmpty { upload.packageName.trim() }, MAX_TITLE_BYTES)))
+        json.append(",\"message\":").append(quote(truncateUtf8(upload.body.trim(), MAX_MESSAGE_BYTES)))
+        json.append(",\"msg_id\":").append(msgId)
+        json.append(",\"subtitle\":").append(quote(truncateUtf8(upload.subtitle.trim(), MAX_SUBTITLE_BYTES)))
+        json.append(",\"time_s\":").append(timestampMs / 1000L)
+        json.append(",\"title\":").append(quote(truncateUtf8(upload.title.trim(), MAX_TITLE_BYTES)))
+        json.append("}}")
+        return json.toString().toByteArray(Charsets.UTF_8)
+    }
+
+    /** Trim to a UTF-8 byte budget without splitting a code point. */
+    fun truncateUtf8(value: String, maxBytes: Int): String {
+        if (value.toByteArray(Charsets.UTF_8).size <= maxBytes) return value
+        val out = StringBuilder()
+        var used = 0
+        var index = 0
+        while (index < value.length) {
+            val codePoint = value.codePointAt(index)
+            val charCount = Character.charCount(codePoint)
+            val chunk = value.substring(index, index + charCount)
+            val size = chunk.toByteArray(Charsets.UTF_8).size
+            if (used + size > maxBytes) break
+            out.append(chunk)
+            used += size
+            index += charCount
+        }
+        return out.toString()
+    }
+
+    private fun writeLittleEndian(out: ByteArrayOutputStream, value: Int) {
+        out.write(value and 0xFF)
+        out.write((value ushr 8) and 0xFF)
+        out.write((value ushr 16) and 0xFF)
+        out.write((value ushr 24) and 0xFF)
+    }
+
+    private fun quote(value: String): String {
+        val out = StringBuilder(value.length + 2)
+        out.append('"')
+        for (char in value) {
+            when {
+                char == '"' -> out.append("\\\"")
+                char == '\\' -> out.append("\\\\")
+                char == '\n' -> out.append("\\n")
+                char == '\r' -> out.append("\\r")
+                char == '\t' -> out.append("\\t")
+                char < ' ' -> out.append(String.format(Locale.US, "\\u%04x", char.code))
+                else -> out.append(char)
+            }
+        }
+        out.append('"')
+        return out.toString()
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.glassly.bluetoothsdk.sgcs
+
+/** Settings field 106, sent as its own notification after the device-info poll by GLASSLYCFW/24 and later.
+ * This is the R1 connected to the glasses, independent of the phone controller.
+ */
+internal data class G2RingBattery(val connected: Boolean, val level: Int, val charging: Boolean) {
+    companion object {
+        val DISCONNECTED = G2RingBattery(false, -1, false)
+
+        fun decode(data: ByteArray): G2RingBattery? {
+            if (data.size != 5 || data[0] != 0x52.toByte() || data[1] != 0x42.toByte() || data[2] != 1.toByte()) return null
+            val flags = data[3].toInt() and 0xff
+            if (flags and 1 == 0) return DISCONNECTED
+            if (flags and 2 == 0) return G2RingBattery(true, -1, false)
+            val level = data[4].toInt() and 0xff
+            if (level > 100) return null
+            return G2RingBattery(true, level, flags and 4 != 0)
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+package com.glassly.bluetoothsdk.sgcs
+
+/** Upstream image modes 16/10 and settings/navigation extension reports. */
+internal object G2Sensors {
+    fun heading(fields: Map<Int, Any>): Int? {
+        if (!fields.containsKey(1)) return 0
+        return (fields[1] as? Int)?.takeIf { it in 0..359 }
+    }
+
+    fun command(sensor: String, operation: String, options: Map<String, Double>): ByteArray? {
+        fun number(key: String, fallback: Int, range: IntRange): Int? {
+            val value = options[key] ?: return fallback
+            if (!value.isFinite() || value % 1.0 != 0.0 || value < range.first || value > range.last) return null
+            return value.toInt()
+        }
+        fun u16(n: Int) = byteArrayOf(n.toByte(), (n shr 8).toByte())
+        if (sensor == "light") {
+            if (operation == "query") return byteArrayOf(16, 0)
+            if (operation == "stop") return byteArrayOf(16, 2)
+            if (operation != "start") return null
+            val interval = number("intervalMs", 500, 100..5000) ?: return null
+            val delta = number("minDelta", 1, 0..65535) ?: return null
+            val heartbeat = number("heartbeatMs", 5000, 0..65535) ?: return null
+            return byteArrayOf(16, 1, 1) + u16(interval) + u16(delta) + u16(heartbeat)
+        }
+        if (sensor == "compass") {
+            if (operation == "stop") return byteArrayOf(10, 0)
+            if (operation != "start") return null
+            val interval = number("intervalMs", 1000, 50..2000) ?: return null
+            val change = number("minChangeDegrees", 5, 0..359) ?: return null
+            return byteArrayOf(10, 2) + u16(interval) + u16(change)
+        }
+        return null
+    }
+    private fun uint(b: ByteArray, offset: Int, count: Int): Long =
+        (0 until count).fold(0L) { n, i -> n or ((b[offset + i].toLong() and 255) shl (8 * i)) }
+    fun light(b: ByteArray): Map<String, Any>? {
+        if (b.size != 24 || b[0] != 65.toByte() || b[1] != 76.toByte() || b[2] != 1.toByte()) return null
+        val reason = b[3].toInt() and 255
+        if (reason > 3) return null
+        val flags = b[4].toInt()
+        return mapOf(
+            "reason" to listOf("query", "started", "poll", "stopped")[reason],
+            "opened" to (flags and 1 != 0), "passive" to (flags and 2 != 0),
+            "autoBrightness" to (flags and 4 != 0), "readSucceeded" to (flags and 8 != 0),
+            "status" to (b[5].toInt() and 255), "value" to uint(b, 6, 4), "peak" to uint(b, 10, 4),
+            "targetLevel" to uint(b, 14, 2), "brightness" to (b[16].toInt() and 255),
+            "gear" to (b[17].toInt() and 255), "scaleQ10" to uint(b, 18, 2),
+            "sampleTimestampMs" to uint(b, 20, 4),
+        )
+    }
+    fun compass(b: ByteArray): Map<String, Any?>? {
+        if (b.size != 12 || b[0] != 67.toByte() || b[1] != 77.toByte() || b[2] != 1.toByte()) return null
+        val accuracy = b[3].toInt() and 255
+        val anomalies = b[4].toInt() and 255
+        val source = b[5].toInt() and 255
+        if ((accuracy > 3 && accuracy != 255) || (anomalies > 2 && anomalies != 255) || source > 3) return null
+        val flags = b[6].toInt()
+        return mapOf(
+            "accuracy" to accuracy.takeUnless { it == 255 }, "anomalies" to anomalies.takeUnless { it == 255 },
+            "source" to listOf("unknown", "grv", "gmrv", "rv")[source],
+            "sampleMatched" to (flags and 128 != 0), "grvValid" to (flags and 1 != 0),
+            "gmrvValid" to (flags and 2 != 0), "rvValid" to (flags and 4 != 0),
+            "magneticDataFresh" to (flags and 8 != 0), "sampleTimestampMs" to uint(b, 8, 4),
+        )
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.glassly.bluetoothsdk.sgcs
+
+/** Captured on the BLE callback thread, before posting input to the main queue. */
+internal data class G2InputArrival(val elapsedMs: Long, val timestamp: Long)
+
+/** CFW field 100: a raw R1 report forwarded once through the right lens. */
+internal data class G2RingInput(val wireType: Int, val tick: Long) {
+    companion object {
+        fun parse(fields: Map<Int, Any>): G2RingInput? {
+            if (fields[2] != 2) return null
+            val data = fields[100] as? ByteArray ?: return null
+            if (data.size != 12) return null
+            val bytes = data.map { it.toInt() and 0xFF }
+            if (bytes[0] != 0x52 || bytes[1] != 0x49 || bytes[2] != 1 || bytes[3] != 1 || bytes[7] != 0) return null
+            val event = when (bytes[4]) {
+                0 -> 9; 1 -> 0; 2 -> 3; 4 -> 1; 5 -> 2; 8 -> 10; 9 -> 11; 10 -> 14
+                else -> 127
+            }
+            if (fields[1] != event) return null
+            val tick = bytes[8].toLong() or (bytes[9].toLong() shl 8) or
+                (bytes[10].toLong() shl 16) or (bytes[11].toLong() shl 24)
+            return G2RingInput(bytes[4], tick)
+        }
+    }
+}
+
+internal class G2TouchDebounce {
+    private var lastAcceptedAt: Long? = null
+
+    fun accepts(event: Int?, ring: G2RingInput?, receivedAt: Long): Boolean {
+        // Preserve the raw ring stream instead of reinstating stock suppression.
+        // Edges and unknown markers never consume a legacy debounce slot.
+        if (ring != null || event == 9 || event == 10 || event == 14 || event == 127) return true
+        val last = lastAcceptedAt
+        if (last != null && receivedAt - last < 100) return false
+        lastAcceptedAt = receivedAt
+        return true
+    }
+}

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

@@ -183,10 +183,10 @@ class MentraLive : SGCManager() {
         private const val POST_SHUTDOWN_RECONNECT_DELAY_MS =
                 10_000L // 10s before first scan after shutdown
 
-        private const val GLASSLY_MANUFACTURER_ID = 0xB822
+        private const val MANUFACTURER_ID = 0xB822
 
         private fun manufacturerData(result: ScanResult): ByteArray? {
-            return result.scanRecord?.getManufacturerSpecificData(GLASSLY_MANUFACTURER_ID)
+            return result.scanRecord?.getManufacturerSpecificData(MANUFACTURER_ID)
         }
 
         private fun isPairingDiscoverable(result: ScanResult): Boolean {
@@ -5895,13 +5895,13 @@ class MentraLive : SGCManager() {
                     Bridge.log("LIVE: Classic: discovery release — cannot list bonded: " + e.message)
                     return
                 }
-        val glasslyBonded =
+        val bondedLiveDevices =
                 bonded.filter { isMentraLiveBluetoothName(safeDeviceName(it)) }
-        if (glasslyBonded.isEmpty()) {
+        if (bondedLiveDevices.isEmpty()) {
             return
         }
         val currentAddress = connectedDevice?.address
-        for (device in glasslyBonded) {
+        for (device in bondedLiveDevices) {
             if (currentAddress != null && device.address.equals(currentAddress, ignoreCase = true)) {
                 continue
             }

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

@@ -30,17 +30,17 @@ import android.os.Looper
 import android.util.Log
 import android.content.Context
 
-import glassly.ble.GlasslyBle.GlassesToPhone
-import glassly.ble.GlasslyBle.PhoneToGlasses
-import glassly.ble.GlasslyBle.ChargingState
-import glassly.ble.GlasslyBle.BatteryStatus
-import glassly.ble.GlasslyBle.HeadGesture
-import glassly.ble.GlasslyBle.ButtonEvent
-import glassly.ble.GlasslyBle.ImuData
-import glassly.ble.GlasslyBle.ImageTransferComplete
-import glassly.ble.GlasslyBle.HeadUpAngleResponse
-import glassly.ble.GlasslyBle.HeadPosition
-import glassly.ble.GlasslyBle.DeviceInfo
+import com.glassly.bluetoothsdk.sgcs.NexProto.GlassesToPhone
+import com.glassly.bluetoothsdk.sgcs.NexProto.PhoneToGlasses
+import com.glassly.bluetoothsdk.sgcs.NexProto.ChargingState
+import com.glassly.bluetoothsdk.sgcs.NexProto.BatteryStatus
+import com.glassly.bluetoothsdk.sgcs.NexProto.HeadGesture
+import com.glassly.bluetoothsdk.sgcs.NexProto.ButtonEvent
+import com.glassly.bluetoothsdk.sgcs.NexProto.ImuData
+import com.glassly.bluetoothsdk.sgcs.NexProto.ImageTransferComplete
+import com.glassly.bluetoothsdk.sgcs.NexProto.HeadUpAngleResponse
+import com.glassly.bluetoothsdk.sgcs.NexProto.HeadPosition
+import com.glassly.bluetoothsdk.sgcs.NexProto.DeviceInfo
 
 import com.glassly.bluetoothsdk.sgcs.SGCManager
 import com.glassly.bluetoothsdk.Bridge
@@ -1292,10 +1292,10 @@ class MentraNex : SGCManager() {
     private fun postProtobufSchemaVersionInfo() {
         try {
             // Call the version method only once
-            val schemaVersion = NexProtobufUtils.getProtobufSchemaVersion(context!!)
+            val schemaVersion = NexProtobufUtils.getProtobufSchemaVersion()
             
             // Build the info string directly instead of calling getProtobufBuildInfo()
-            val fileDescriptorName = glassly.ble.GlasslyBle.getDescriptor().file.name
+            val fileDescriptorName = NexProto.getDescriptor().file.name
             val buildInfo = "Schema v$schemaVersion | $fileDescriptorName"
 
             // protobufSchemaVersion = schemaVersion.toString()
@@ -1764,7 +1764,7 @@ class MentraNex : SGCManager() {
                     // a diagnosable log line. Non-OK codes also invalidate the
                     // registry entry so the next frame recreates the component.
                     val canvasResult = glassesToPhone.canvasResult
-                    if (canvasResult.code != glassly.ble.GlasslyBle.CanvasResult.ResultCode.OK) {
+                    if (canvasResult.code != NexProto.CanvasResult.ResultCode.OK) {
                         Bridge.log("Nex: CANVAS_RESULT id=${canvasResult.id} code=${canvasResult.code} — dropping registry entry for recreate")
                         canvasElements.entries.removeAll { it.value.firmwareId == canvasResult.id.toInt() }
                     }