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

package/android/src/main/java/com/glassly/bluetoothsdk/DeviceManager.kt

@@ -17,6 +17,7 @@ import com.glassly.bluetoothsdk.services.PhoneMic
 import com.glassly.bluetoothsdk.sgcs.Ar99
 import com.glassly.bluetoothsdk.sgcs.G1
 import com.glassly.bluetoothsdk.sgcs.G2
+import com.glassly.bluetoothsdk.sgcs.G2KeyboardBridge
 import com.glassly.bluetoothsdk.sgcs.SceneElement
 import com.glassly.bluetoothsdk.sgcs.SceneFrame
 import com.glassly.bluetoothsdk.sgcs.Mach1
@@ -33,6 +34,7 @@ import com.glassly.bluetoothsdk.utils.PhoneAudioMonitor
 import com.glassly.lc3Lib.Lc3Cpp
 import com.glassly.bluetoothsdk.speakerid.SpeakerIdEngine
 import com.glassly.bluetoothsdk.stt.SherpaOnnxTranscriber
+import com.glassly.bluetoothsdk.stt.VadGateSpeechPolicy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -267,7 +269,7 @@ class DeviceManager {
     // VAD
     private val vadBuffer = mutableListOf<ByteArray>()
     private var isSpeaking = false
-    private var vadPolicy: com.glassly.bluetoothsdk.stt.VadGateSpeechPolicy? = null
+    private var vadPolicy: VadGateSpeechPolicy? = null
 
     // STT
     private var transcriber: SherpaOnnxTranscriber? = null
@@ -306,7 +308,7 @@ class DeviceManager {
         try {
             vadPolicy?.stop()
             val ctx = Bridge.getContext()
-            val policy = com.glassly.bluetoothsdk.stt.VadGateSpeechPolicy(ctx)
+            val policy = VadGateSpeechPolicy(ctx)
             policy.init(blockSizeSamples = 512)
             policy.onSpeechStateChanged = { speaking ->
                 isSpeaking = speaking
@@ -703,6 +705,27 @@ class DeviceManager {
     // native re-dispatch coherent (nav exit re-applies a complete scene, not
     // whatever element happened to arrive last).
     private var sceneState: SceneFrame? = null
+
+    /**
+     * Paces scene frames and legacy layouts to display_max_fps; clears bypass it.
+     * CFW scene drivers coalesce off the link themselves, so they bypass it too.
+     */
+    private val pacer =
+        DisplayPacer(dispatchScene = { dispatchSceneFrame(it) }, sendLegacy = { sendCurrentState() }).also {
+            it.setMaxFps((DeviceStore.store.get("bluetooth", "display_max_fps") as? Number)?.toInt() ?: DisplayPacer.DEFAULT_FPS)
+        }
+
+    fun setDisplayMaxFps(fps: Int) = pacer.setMaxFps(fps)
+
+    /**
+     * CFW identity can land after device-ready, so this is re-read per update;
+     * the flush variants fold any frame already held into the immediate send.
+     */
+    private val pacerBypassed: Boolean
+        get() = sgc?.supportsCfwSceneRendering == true
+
+    /** Drop paced display work (screen off): the retained state repaints on re-enable. */
+    fun cancelPendingDisplay() = pacer.cancel()
     // MARK: - End Unique
 
     // MARK: - Voice Data Handling
@@ -1208,6 +1231,7 @@ class DeviceManager {
         if (sgc != null && sgc?.type != wearable) {
             Bridge.log("MAN: Manager already initialized, cleaning up previous sgc")
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
+            pacer.cancel()
             sgc?.cleanup()
             sgc = null
             resetSystemTimeSync()
@@ -1276,9 +1300,10 @@ class DeviceManager {
 
     fun restartTranscriber() {
         Bridge.log("MAN: Restarting transcriber via command")
-        if (ensureTranscriberInitialized()) {
-            transcriber?.restart()
-        }
+        check(ensureTranscriberInitialized()) { "Offline speech recognizer initialization failed" }
+        val activeTranscriber = checkNotNull(transcriber)
+        activeTranscriber.restart()
+        check(activeTranscriber.isInitialized()) { "Offline speech recognizer restart failed" }
     }
 
     // MARK: - Speaker identification
@@ -1580,6 +1605,7 @@ class DeviceManager {
 
     fun clearDisplay() {
         Bridge.log("MAN: Clearing Display")
+        pacer.cancel()
         sgc?.clearDisplay()
     }
 
@@ -1647,7 +1673,11 @@ class DeviceManager {
         }
 
         viewState = newViewState
-        sendCurrentState()
+        if (layoutType == "clear_view" || pacerBypassed) {
+            pacer.flushLegacy()
+        } else {
+            pacer.submitLegacy()
+        }
     }
 
     /** Parse + store a scene frame, then dispatch it. */
@@ -1682,15 +1712,28 @@ class DeviceManager {
             frame.copy(replay = true, elements = frame.elements.map { it.copy(change = "created") })
         viewState = ViewState(" ", " ", " ", "scene", " ", null, null)
 
-        dispatchSceneFrame(frame)
+        if (frame.elements.isEmpty() || pacerBypassed) {
+            pacer.flushScene(frame)
+        } else {
+            pacer.submitScene(frame)
+        }
     }
 
     /** Guarded scene dispatch — mirrors sendCurrentState's send conditions. */
     private fun dispatchSceneFrame(frame: SceneFrame) {
-        if (screenDisabled) return
-        if (sgc?.type?.contains(DeviceTypes.SIMULATED) == true) return
+        // Each early-out tells the host the frame won't show now; the SGC
+        // reports the rest once the device has it.
+        if (screenDisabled) {
+            frame.reportPresented(false, "screen off")
+            return
+        }
+        if (sgc?.type?.contains(DeviceTypes.SIMULATED) == true) {
+            frame.reportPresented(false, "simulated glasses")
+            return
+        }
         if (sgc?.fullyBooted != true) {
             Bridge.log("MAN: dispatchSceneFrame(): sgc not ready")
+            frame.reportPresented(false, if (sgc == null) "no glasses" else "glasses not ready")
             return
         }
         sgc?.applySceneFrame(frame)
@@ -1703,6 +1746,15 @@ class DeviceManager {
             elementsRaw.mapNotNull { el ->
                 val box = el["box"] as? Map<String, Any> ?: return@mapNotNull null
                 val style = el["style"] as? Map<String, Any>
+                val transition = el["transition"] as? Map<String, Any>
+                val points =
+                    (el["points"] as? List<*>)?.flatMap { p ->
+                        val point = p as? Map<*, *>
+                        listOf((point?.get("x") as? Number)?.toInt() ?: 0, (point?.get("y") as? Number)?.toInt() ?: 0)
+                    } ?: emptyList()
+                // Open strokes carry their width as `width`; closed shapes and boxes as `border`.
+                val border =
+                    (style?.get("border") as? Number)?.toInt() ?: (style?.get("width") as? Number)?.toInt() ?: 0
                 SceneElement(
                     id = el["id"] as? String ?: return@mapNotNull null,
                     type = el["type"] as? String ?: return@mapNotNull null,
@@ -1712,15 +1764,30 @@ class DeviceManager {
                     h = (box["h"] as? Number)?.toInt() ?: 0,
                     text = (el["text"] as? String)?.let { parsePlaceholders(it) },
                     data = el["data"] as? String,
-                    border = (style?.get("border") as? Number)?.toInt() ?: 0,
+                    border = border,
                     radius = (style?.get("radius") as? Number)?.toInt() ?: 0,
                     change = el["change"] as? String ?: "created",
                     contentHash = el["contentHash"] as? String ?: "",
                     font = style?.get("font") as? String ?: "default",
                     fontSize = (style?.get("fontSize") as? Number)?.toInt() ?: 0,
+                    fill = style?.get("fill") as? Boolean ?: false,
+                    color = (style?.get("color") as? Number)?.toInt() ?: -1,
+                    points = points,
+                    startDeg = (el["startDeg"] as? Number)?.toInt() ?: 0,
+                    endDeg = (el["endDeg"] as? Number)?.toInt() ?: 0,
+                    transitionMs = (transition?.get("durationMs") as? Number)?.toInt() ?: 0,
+                    easing = transition?.get("easing") as? String ?: "ease",
+                    path = (el["path"] as? List<*>)?.map { (it as? Number)?.toInt()?.coerceIn(0, 255) ?: 0 } ?: emptyList(),
+                    pathScale = (el["pathScale"] as? Number)?.toInt() ?: 256,
+                    fillRule = if (el["fillRule"] == "evenodd") 1 else 0,
+                    rotationQ8 = (((el["rotation"] as? Number)?.toDouble() ?: 0.0) * 256).coerceIn(-9216000.0, 9216000.0).toInt(),
+                    pivotX = ((el["pivot"] as? Map<*, *>)?.get("x") as? Number)?.toInt(),
+                    pivotY = ((el["pivot"] as? Map<*, *>)?.get("y") as? Number)?.toInt(),
+                    depth = (el["depth"] as? Number)?.toInt() ?: 0,
                 )
             }
         val canvas = sceneMap["canvas"] as? Map<String, Any>
+
         return SceneFrame(
             appId = sceneMap["appId"] as? String ?: "",
             epoch = (sceneMap["sceneEpoch"] as? Number)?.toInt() ?: 0,
@@ -1731,6 +1798,7 @@ class DeviceManager {
                 ?: SceneFrame.DEFAULT_CANVAS_WIDTH,
             canvasHeight = (canvas?.get("height") as? Number)?.toInt()?.takeIf { it > 0 }
                 ?: SceneFrame.DEFAULT_CANVAS_HEIGHT,
+            seq = (sceneMap["seq"] as? Number)?.toInt() ?: 0,
         )
     }
 
@@ -1740,6 +1808,9 @@ class DeviceManager {
 
     // ---------- Native navigation (glasses-rendered nav UI, e.g. G2 service 0x08) ----------
 
+    suspend fun glassesSensorControl(sensor: String, operation: String, options: Map<String, Double>): Boolean =
+        (sgc as? G2)?.glassesSensorControl(sensor, operation, options) ?: false
+
     fun navigationModeStart() {
         sgc?.enterNavigationMode()
     }
@@ -1792,6 +1863,19 @@ class DeviceManager {
         }
     }
 
+    fun setGlassesNotificationConfig(config: GlassesNotificationConfig) {
+        val manager = sgc ?: throw IllegalStateException("Glasses are not connected")
+        manager.setGlassesNotificationConfig(config)
+    }
+
+    fun glassesNotificationStatus(): GlassesNotificationStatus =
+        sgc?.glassesNotificationStatus() ?: GlassesNotificationStatus.unsupported()
+
+    fun uploadPhoneNotification(upload: PhoneNotificationUpload) {
+        val manager = sgc ?: throw IllegalStateException("Glasses are not connected")
+        manager.uploadPhoneNotification(upload)
+    }
+
     fun ping() {
         sgc?.ping()
     }
@@ -1806,6 +1890,16 @@ class DeviceManager {
         sgc?.dbg2()
     }
 
+    fun dbg3() {
+        Bridge.log("MAN: dbg3()")
+        sgc?.dbg3()
+    }
+
+    fun dbg4() {
+        Bridge.log("MAN: dbg4()")
+        sgc?.dbg4()
+    }
+
     fun startStream(message: MutableMap<String, Any>) {
         Bridge.log("MAN: startStream")
         sgc?.startStream(message)
@@ -2066,6 +2160,40 @@ class DeviceManager {
         return g2.startFirmwareFlash(target)
     }
 
+    // ---------- BLE keyboard bridge (G2 Glassly CFW revision 39+) ----------
+
+    private fun requireG2ForKeyboard(): G2 =
+        sgc as? G2 ?: throw G2KeyboardBridge.BridgeException("The keyboard bridge needs connected G2 glasses.")
+
+    suspend fun g2KeyboardScan(): List<Map<String, Any>> = requireG2ForKeyboard().keyboardScan()
+
+    suspend fun g2KeyboardConnect(address: String, addressType: Int, name: String) =
+        requireG2ForKeyboard().keyboardConnect(address, addressType, name)
+
+    suspend fun g2KeyboardReconnect() = requireG2ForKeyboard().keyboardReconnect()
+
+    suspend fun g2KeyboardDisconnect() {
+        (sgc as? G2)?.keyboardDisconnect()
+    }
+
+    suspend fun g2KeyboardForget() {
+        val g2 = sgc as? G2
+        if (g2 != null) {
+            g2.keyboardForget()
+        } else {
+            // No live G2 driver: drop the remembered identity directly.
+            G2KeyboardBridge.forgetSaved(Bridge.getContext().getSharedPreferences("G2Prefs", Context.MODE_PRIVATE))
+        }
+    }
+
+    suspend fun g2KeyboardPasskey(pin: Int) = requireG2ForKeyboard().keyboardPasskey(pin)
+
+    suspend fun g2KeyboardCompare(accept: Boolean) = requireG2ForKeyboard().keyboardCompare(accept)
+
+    suspend fun g2KeyboardStatus(): Map<String, Any> =
+        (sgc as? G2)?.keyboardStatus()
+            ?: mapOf("keyboardBridge" to false, "keyboardConnected" to false, "keyboardState" to "idle")
+
     /** Send shutdown command to glasses. This will initiate a graceful shutdown of the device. */
     fun sendShutdown() {
         Bridge.log("MAN: 🔌 Sending shutdown command to glasses")
@@ -2280,6 +2408,7 @@ class DeviceManager {
     }
 
     fun disconnect(clearPendingIdentity: Boolean = true) {
+        pacer.cancel()
         sgc?.clearDisplay()
         sgc?.disconnect()
         sgc = null // Clear the SGC reference after disconnect

package/android/src/main/java/com/glassly/bluetoothsdk/DeviceStore.kt

@@ -72,8 +72,19 @@ object DeviceStore {
         store.set("glasses", "caseRemoved", true)
         store.set("glasses", "caseOpen", true)
         store.set("glasses", "caseCharging", false)
+        store.set("glasses", "ringConnected", false)
+        store.set("glasses", "ringBatteryLevel", -1)
+        store.set("glasses", "ringCharging", false)
         store.set("glasses", "caseBatteryLevel", -1)
         store.set("glasses", "headUp", false)
+        // G2 Glassly CFW keyboard bridge (revision 39+): availability on the
+        // connected firmware, the live keyboard link, and the remembered keyboard.
+        store.set("glasses", "keyboardBridge", false)
+        store.set("glasses", "keyboardConnected", false)
+        store.set("glasses", "keyboardName", "")
+        store.set("glasses", "keyboardSaved", false)
+        store.set("glasses", "keyboardState", "idle")
+        store.set("glasses", "keyboardError", "")
         store.set("glasses", "bluetoothMacAddress", "")
         store.set("glasses", "wifiMacAddress", "")
         store.set("glasses", "leftMacAddress", "")
@@ -132,6 +143,9 @@ object DeviceStore {
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "display_max_fps", DisplayPacer.DEFAULT_FPS)
+        // Debug: G2 CFW fast BLE link profile (off = stock connection behaviour).
+        store.set("bluetooth", "cfw_fast_ble", false)
         store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_max_recording_time", 10)
         store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
@@ -145,7 +159,6 @@ object DeviceStore {
         store.set("bluetooth", "should_send_pcm", false)
         store.set("bluetooth", "should_send_lc3", false)
         store.set("bluetooth", "should_send_transcript", false)
-        store.set("bluetooth", "use_native_dashboard", false)
         // Mentra Nex feature flags (off by default; toggled from Nex Developer Settings):
         store.set("bluetooth", "nex_chinese_captions", false)
         store.set("bluetooth", "nex_lc3_audio_playback", false)
@@ -241,6 +254,19 @@ object DeviceStore {
                     }
                 }
             }
+            "bluetooth" to "cfw_fast_ble" -> {
+                val enabled = value as? Boolean
+                if (enabled != null && (oldValue as? Boolean) != enabled) {
+                    CoroutineScope(Dispatchers.Main).launch {
+                        DeviceManager.getInstance().sgc?.cfwFastBleToggled(enabled)
+                    }
+                }
+            }
+            "bluetooth" to "display_max_fps" -> {
+                (value as? Number)?.let { fps ->
+                    DeviceManager.getInstance().setDisplayMaxFps(fps.toInt())
+                }
+            }
             "bluetooth" to "dashboard_height" -> {
                 scheduleDashboardHeightToGlasses()
             }
@@ -294,6 +320,7 @@ object DeviceStore {
             "bluetooth" to "screen_disabled" -> {
                 (value as? Boolean)?.let { disabled ->
                     if (disabled) {
+                        DeviceManager.getInstance().cancelPendingDisplay()
                         DeviceManager.getInstance().sgc?.exit()
                     } else {
                         DeviceManager.getInstance().sgc?.clearDisplay()

package/android/src/main/java/com/glassly/bluetoothsdk/DisplayPacer.kt

@@ -0,0 +1,199 @@
+package com.glassly.bluetoothsdk
+
+import android.os.Handler
+import android.os.Looper
+import com.glassly.bluetoothsdk.sgcs.SceneFrame
+
+/**
+ * Paces display updates leaving the phone to at most [setMaxFps] per second.
+ *
+ * Updates that arrive inside the current slot are held and sent at the next
+ * one, last-wins: a newer scene frame replaces a pending one (with the pending
+ * frame's per-element annotations folded in so per-element devices never miss
+ * a change), a legacy layout replaces a pending scene and vice versa. Clears
+ * ([flushScene] with an empty frame, [flushLegacy]) bypass the pacer and drop
+ * pending work.
+ *
+ * Safe to call from any thread; the trailing send runs on the scheduler's
+ * thread (main looper by default). Sinks are always invoked outside the lock.
+ */
+class DisplayPacer(
+    private val dispatchScene: (SceneFrame) -> Unit,
+    private val sendLegacy: () -> Unit,
+    private val clock: () -> Long = { System.nanoTime() / 1_000_000 },
+    private val scheduler: Scheduler = MainScheduler(),
+) {
+    /** Runs [block] after [delayMs]; the returned function cancels it. */
+    fun interface Scheduler {
+        fun schedule(delayMs: Long, block: () -> Unit): () -> Unit
+    }
+
+    private class MainScheduler : Scheduler {
+        private val handler = Handler(Looper.getMainLooper())
+
+        override fun schedule(delayMs: Long, block: () -> Unit): () -> Unit {
+            val runnable = Runnable { block() }
+            handler.postDelayed(runnable, delayMs)
+            return { handler.removeCallbacks(runnable) }
+        }
+    }
+
+    companion object {
+        const val MIN_FPS = 2
+        const val MAX_FPS = 20
+        const val DEFAULT_FPS = 8
+
+        fun intervalFor(fps: Int): Long = 1000L / fps.coerceIn(MIN_FPS, MAX_FPS)
+
+        /**
+         * Fold pending frame [previous] into [next] (both unsent). The device
+         * only ever sees the merged frame, so an element the pending frame
+         * changed must not read as "unchanged" in the merged one, and ids the
+         * pending frame removed must still be removed unless [next] re-creates
+         * them. A different app is already a from-scratch replay.
+         */
+        fun merge(previous: SceneFrame?, next: SceneFrame): SceneFrame {
+            if (previous == null || previous.appId != next.appId) return next
+            val pending = previous.elements.associateBy { it.id }
+            val elements =
+                next.elements.map { el ->
+                    val prior = pending[el.id] ?: return@map el
+                    when {
+                        prior.change == "created" -> el.copy(change = "created")
+                        prior.change != "unchanged" && el.change == "unchanged" -> el.copy(change = "updated")
+                        else -> el
+                    }
+                }
+            val painted = next.elements.mapTo(HashSet()) { it.id }
+            val removed = (previous.removed + next.removed).distinct().filter { it !in painted }
+            return next.copy(replay = previous.replay || next.replay, elements = elements, removed = removed)
+        }
+    }
+
+    private val lock = Any()
+    private var intervalMs: Long = intervalFor(DEFAULT_FPS)
+    private var lastSendAt: Long = Long.MIN_VALUE / 2
+    private var pendingScene: SceneFrame? = null
+    private var pendingLegacy = false
+    private var cancelTimer: (() -> Unit)? = null
+
+    fun setMaxFps(fps: Int) {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            intervalMs = intervalFor(fps)
+            if (!hasPending()) return
+            stopTimer()
+            send = armOrTake(clock())
+        }
+        send?.invoke()
+    }
+
+    /** Send [frame] at the next slot; replaces any pending update. */
+    fun submitScene(frame: SceneFrame) {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            val now = clock()
+            val merged = merge(pendingScene, frame)
+            pendingScene = merged
+            pendingLegacy = false
+            if (now - lastSendAt >= intervalMs) {
+                stopTimer()
+                send = take(now)
+            } else if (cancelTimer == null) {
+                armTimer(now)
+            }
+        }
+        send?.invoke()
+    }
+
+    /** Send the current legacy view state at the next slot; replaces any pending update. */
+    fun submitLegacy() {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            val now = clock()
+            pendingScene = null
+            pendingLegacy = true
+            if (now - lastSendAt >= intervalMs) {
+                stopTimer()
+                send = take(now)
+            } else if (cancelTimer == null) {
+                armTimer(now)
+            }
+        }
+        send?.invoke()
+    }
+
+    /** Immediate send for an empty (clearing) frame; pending removes ride along. */
+    fun flushScene(frame: SceneFrame) {
+        val merged: SceneFrame
+        synchronized(lock) {
+            stopTimer()
+            merged = merge(pendingScene, frame)
+            pendingScene = null
+            pendingLegacy = false
+            lastSendAt = clock()
+        }
+        dispatchScene(merged)
+    }
+
+    /** Immediate legacy send (clear_view); drops any pending scene. */
+    fun flushLegacy() {
+        synchronized(lock) {
+            stopTimer()
+            pendingScene = null
+            pendingLegacy = false
+            lastSendAt = clock()
+        }
+        sendLegacy()
+    }
+
+    /** Drop pending work without sending (disconnect, screen off, clearDisplay). */
+    fun cancel(reason: String = "cancelled") {
+        synchronized(lock) {
+            stopTimer()
+            pendingScene?.reportPresented(false, reason)
+            pendingScene = null
+            pendingLegacy = false
+        }
+    }
+
+    private fun hasPending() = pendingScene != null || pendingLegacy
+
+    private fun stopTimer() {
+        cancelTimer?.invoke()
+        cancelTimer = null
+    }
+
+    /** Lock held. Either sends now (returns the send) or arms the slot timer. */
+    private fun armOrTake(now: Long): (() -> Unit)? {
+        if (now - lastSendAt >= intervalMs) return take(now)
+        armTimer(now)
+        return null
+    }
+
+    /** Lock held. Consume pending work into a send closure and stamp the slot. */
+    private fun take(now: Long): (() -> Unit)? {
+        val scene = pendingScene
+        val legacy = pendingLegacy
+        pendingScene = null
+        pendingLegacy = false
+        if (scene == null && !legacy) return null
+        lastSendAt = now
+        return if (scene != null) ({ dispatchScene(scene) }) else ({ sendLegacy() })
+    }
+
+    /** Lock held. Arm the single trailing timer for the next slot. */
+    private fun armTimer(now: Long) {
+        val delay = (lastSendAt + intervalMs - now).coerceAtLeast(0)
+        cancelTimer = scheduler.schedule(delay) { onTimer() }
+    }
+
+    private fun onTimer() {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            cancelTimer = null
+            send = take(clock())
+        }
+        send?.invoke()
+    }
+}

package/android/src/main/java/com/glassly/bluetoothsdk/GeneratedChangelogCatalog.kt

@@ -4,6 +4,15 @@ package com.glassly.bluetoothsdk
 internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
     listOf(
         ReleaseChangelog(version = "3.2.0", markdown = "This release is under active development. User-facing changes will be documented as they land."),
-        ReleaseChangelog(version = "3.1.0", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- GlasslyOS, Glassly Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+        ReleaseChangelog(version = "3.1.0", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- Glassly, Glassly Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+        ReleaseChangelog(version = "0.2.8", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.7", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.6", markdown = "- Terminal follows light and dark mode, removes the on-glasses status badge, and uses font-scaled line spacing in the glasses session picker.\n- Notifications uses the explicit 5-second popup default and prevents text selection on iOS.\n- The session.display example removes the SVG and rotation demo."),
+        ReleaseChangelog(version = "0.2.5", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.4", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.3", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.2", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.1", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "0.2.0", markdown = "The glasses UI on Glassly CFW is now a set of pages over one overlay: the dashboard, side menu, calendar, notification viewer and debug menu each stand on their own.\n\n- A phone notification shows the viewer on its own and closes back to whatever was on the glasses; it no longer opens the dashboard first, and the ignore-while-active hold is honoured everywhere on custom firmware.\n- Double tap on any page returns to the main content; head-down closes only the dashboard.\n- A debug menu on the dashboard (Debug Settings toggle) queries phone-side state such as isPhoneActive().\n- The metric toggle moved to Appearance, and miniapps can read the host's preferences.\n- Messenger group threads show on the notification title row."),
         ReleaseChangelog(version = "0.1.0", markdown = "First coordinated Glassly release: the app, Glassly Engine, and the Bluetooth SDK now ship one shared release version.\n\n- The Glassly App, Glassly Engine, and the Bluetooth SDK are versioned and published together.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
     )

package/android/src/main/java/com/glassly/bluetoothsdk/GeneratedReleaseMetadata.kt

@@ -2,10 +2,10 @@ package com.glassly.bluetoothsdk
 
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
-    const val FAMILY_BASE_VERSION: String = "0.1.0"
-    const val RELEASE_IDENTITY: String = "0.1.0-dev.99"
-    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.99"
-    const val SOURCE_COMMIT: String = "2aeea5db8ad4e84303faf84a92d025f0d1930ebf"
+    const val FAMILY_BASE_VERSION: String = "0.2.8"
+    const val RELEASE_IDENTITY: String = "0.2.8-dev.444"
+    const val RELEASE_SET_ID: String = "glassly-0.2.8-dev.444"
+    const val SOURCE_COMMIT: String = "9ad99e635c0320d07373d42bb7422daf5289d49d"
     const val OTA_MANIFEST_URL: String = ""
     const val OTA_MANIFEST_SHA256: String = ""
 }