@glassly/bluetooth-sdk 0.1.0-dev.112 → 0.1.0-dev.114

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

@@ -703,6 +703,17 @@ 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. */
+    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)
+
+    /** 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 +1219,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()
@@ -1580,6 +1592,7 @@ class DeviceManager {
 
     fun clearDisplay() {
         Bridge.log("MAN: Clearing Display")
+        pacer.cancel()
         sgc?.clearDisplay()
     }
 
@@ -1647,7 +1660,11 @@ class DeviceManager {
         }
 
         viewState = newViewState
-        sendCurrentState()
+        if (layoutType == "clear_view") {
+            pacer.flushLegacy()
+        } else {
+            pacer.submitLegacy()
+        }
     }
 
     /** Parse + store a scene frame, then dispatch it. */
@@ -1682,7 +1699,11 @@ 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()) {
+            pacer.flushScene(frame)
+        } else {
+            pacer.submitScene(frame)
+        }
     }
 
     /** Guarded scene dispatch — mirrors sendCurrentState's send conditions. */
@@ -2306,6 +2327,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

@@ -132,6 +132,7 @@ 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)
         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))
@@ -241,6 +242,11 @@ object DeviceStore {
                     }
                 }
             }
+            "bluetooth" to "display_max_fps" -> {
+                (value as? Number)?.let { fps ->
+                    DeviceManager.getInstance().setDisplayMaxFps(fps.toInt())
+                }
+            }
             "bluetooth" to "dashboard_height" -> {
                 scheduleDashboardHeightToGlasses()
             }
@@ -294,6 +300,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,198 @@
+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() {
+        synchronized(lock) {
+            stopTimer()
+            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/GeneratedReleaseMetadata.kt

@@ -3,9 +3,9 @@ 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.112"
-    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.112"
-    const val SOURCE_COMMIT: String = "385c3de9054122bf005790a6b1faf04d3117d512"
+    const val RELEASE_IDENTITY: String = "0.1.0-dev.114"
+    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.114"
+    const val SOURCE_COMMIT: String = "17263133b35c04f044ba0d3acd9f80efc81999d4"
     const val OTA_MANIFEST_URL: String = ""
     const val OTA_MANIFEST_SHA256: String = ""
 }

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

@@ -1578,6 +1578,13 @@ class G2 : SGCManager() {
             supportsCfwSceneRendering &&
                 listOf("scene17", "shapes16", "anim18", "texcache12", "teximg13", "font15").all { it in cfwFeatures }
 
+    /**
+     * TEXT_INLINE records (contract revision 19; no token, the capability
+     * response must fit one BLE frame): default text drawn by the glasses' font.
+     */
+    private val supportsCfwInlineText: Boolean
+        get() = cfwProtocolVersion >= 19
+
     /** The on-glass slot table must be re-SET on the next vector frame. */
     private var cfwSceneInvalid = true
 
@@ -3104,9 +3111,10 @@ class G2 : SGCManager() {
         }
         if (cfwLastBoxes != boxes) cfwSceneInvalid = true
         val invalidate = cfwSceneInvalid
+        val inlineText = supportsCfwInlineText
         val encoded =
             kotlinx.coroutines.withContext(Dispatchers.Default) {
-                G2CfwRenderer.encodeVector(frame, boxes, cfwCacheGeneration, invalidate)
+                G2CfwRenderer.encodeVector(frame, boxes, cfwCacheGeneration, invalidate, inlineText)
             }
         if (encoded == null) {
             Bridge.log("G2: vector scene does not fit; using the raster path for this frame")

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

@@ -87,6 +87,7 @@ internal object G2CfwRenderer {
         boxes: LensBoxes,
         cacheGeneration: Int,
         invalidate: Boolean,
+        inlineText: Boolean,
     ): G2CfwScene.Encoded? {
         if (textureCache.generation != cacheGeneration || textureCache.exhausted) {
             textureCache.reset(cacheGeneration)
@@ -103,11 +104,11 @@ internal object G2CfwRenderer {
                 h,
             )
         }
-        scene.encode(frame, boxes.leftX, boxes.leftY, textureCache, rasterizeOne)?.let { return it }
+        scene.encode(frame, boxes.leftX, boxes.leftY, textureCache, rasterizeOne, inlineText)?.let { return it }
         // Out of texture cache mid-frame: start a fresh cache and repack once.
         textureCache.reset(cacheGeneration)
         scene.reset(cacheGeneration)
-        return scene.encode(frame, boxes.leftX, boxes.leftY, textureCache, rasterizeOne)
+        return scene.encode(frame, boxes.leftX, boxes.leftY, textureCache, rasterizeOne, inlineText)
     }
     private val glyphRasterMemo = mutableMapOf<String, ByteArray>()
 

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

@@ -6,13 +6,14 @@ import java.io.ByteArrayOutputStream
  * Retained vector scene for the Glassly CFW (firmware modes 16-18).
  *
  * Every scene element becomes one or more firmware slots (paint order = slot
- * order): vector shapes map 1:1, builtin-font text becomes one TEXT slot per
- * line with its bytes in the texture cache, and everything else (proportional
- * text, images) is rasterized on the phone and drawn as cached IMAGE slots
- * tiled to the 255 px slot limit. Frames diff against the last committed
- * layout: unchanged slots cost nothing, geometry changes on an element with a
- * transition become firmware TWEENs, and anything else is re-SET. Slot indices
- * stay stable per element id; a reorder or an over-budget frame repacks.
+ * order): vector shapes map 1:1; default and builtin text becomes one inline
+ * TEXT slot per line drawn by the glasses' font (or a cache-backed TEXT slot on
+ * firmware without inline records); mono text and images are rasterized on
+ * the phone and drawn as cached IMAGE slots tiled to the 255 px slot limit.
+ * Frames diff against the last committed layout: unchanged slots cost nothing,
+ * geometry changes on an element with a transition become firmware TWEENs, and
+ * anything else is re-SET. Slot indices stay stable per element id; a reorder
+ * or an over-budget frame repacks.
  */
 internal class G2CfwScene {
     companion object {
@@ -20,7 +21,9 @@ internal class G2CfwScene {
         const val RECORD_BYTES = 20
         const val FRAME_PERIOD_MS = 33.0
         const val TEXT_LINE_HEIGHT = 27
+        const val TEXT_INSET = 2
         const val MAX_TEXT_BYTES = 64
+        const val MAX_INLINE_BYTES = 128
         const val MAX_TILE_SIZE = 255
         /** Mode-13/15 options: identity ramp, transparent source color 0. */
         const val TEXT_OPTIONS = 0x1F
@@ -42,6 +45,7 @@ internal class G2CfwScene {
         const val TYPE_IMAGE = 14
         const val TYPE_TEXT = 15
         const val TYPE_TEXT_CACHED = 16
+        const val TYPE_TEXT_INLINE = 17
 
         /** Geometry parameters a TWEEN may interpolate, per type. Texture offsets and lengths never tween. */
         fun tweenableMask(type: Int): Int =
@@ -52,6 +56,7 @@ internal class G2CfwScene {
                 TYPE_TRI, TYPE_TRI_FILL, TYPE_BEZIER2 -> 0x3F
                 TYPE_QUAD, TYPE_QUAD_FILL, TYPE_BEZIER3 -> 0xFF
                 TYPE_IMAGE, TYPE_TEXT, TYPE_TEXT_CACHED -> 0x03
+                TYPE_TEXT_INLINE -> 0x0F
                 else -> 0
             }
 
@@ -71,7 +76,7 @@ internal class G2CfwScene {
         }
 
         /** UTF-8 bytes of a line without firmware control bytes (1..31), cut at a codepoint boundary. */
-        fun textBytes(line: String): ByteArray {
+        fun textBytes(line: String, limit: Int = MAX_TEXT_BYTES): ByteArray {
             val out = ByteArrayOutputStream()
             var i = 0
             while (i < line.length) {
@@ -79,7 +84,7 @@ internal class G2CfwScene {
                 i += Character.charCount(cp)
                 if (cp < 32) continue
                 val encoded = String(Character.toChars(cp)).toByteArray(Charsets.UTF_8)
-                if (out.size() + encoded.size > MAX_TEXT_BYTES) break
+                if (out.size() + encoded.size > limit) break
                 out.write(encoded)
             }
             return out.toByteArray()
@@ -96,7 +101,10 @@ internal class G2CfwScene {
             out.write((value ushr 8) and 0xFF)
         }
 
-        /** `[0][slot][type][flags=visible][color][width][p0..p7 LE]` */
+        /**
+         * `[0][slot][type][flags=visible][color][width][p0..p7 LE]`, or for TEXT_INLINE
+         * `[0][slot][17][1][color][width][x][y][w][h][len][bytes]`.
+         */
         fun setRecord(slot: Slot, index: Int): ByteArray {
             val out = ByteArrayOutputStream()
             out.write(0)
@@ -105,7 +113,13 @@ internal class G2CfwScene {
             out.write(1)
             out.write(slot.color)
             out.write(slot.width)
-            for (value in slot.params) le(out, value)
+            val inline = slot.type == TYPE_TEXT_INLINE
+            for (k in 0 until (if (inline) 4 else 8)) le(out, slot.params[k])
+            if (inline) {
+                val bytes = slot.text.take(MAX_INLINE_BYTES).toByteArray()
+                out.write(bytes.size)
+                out.write(bytes)
+            }
             return out.toByteArray()
         }
 
@@ -114,7 +128,7 @@ internal class G2CfwScene {
          * change is not a pure geometry/stroke change of the same shape type.
          */
         fun tweenRecord(old: Slot, new: Slot, index: Int, frames: Int, curve: IntArray): ByteArray? {
-            if (old.type != new.type) return null
+            if (old.type != new.type || !old.text.contentEquals(new.text)) return null
             val tweenable = tweenableMask(new.type)
             var mask = 0
             val values = mutableListOf<Int>()
@@ -126,7 +140,9 @@ internal class G2CfwScene {
             }
             val isTexture = new.type >= TYPE_IMAGE
             if (old.color != new.color) {
-                if (isTexture) return null
+                // Inline text may fade (low nibble) as long as its option bits stay put.
+                val inlineFade = new.type == TYPE_TEXT_INLINE && (old.color and 0xF0) == (new.color and 0xF0)
+                if (isTexture && !inlineFade) return null
                 mask = mask or 0x100
                 values.add(new.color)
             }
@@ -147,15 +163,19 @@ internal class G2CfwScene {
         }
     }
 
-    /** One firmware slot: type, 4-bit color (or options byte), stroke width, eight int16 parameters. */
-    class Slot(val type: Int, val color: Int, val width: Int, params: List<Int>) {
+    /**
+     * One firmware slot: type, 4-bit color (or options byte), stroke width, eight
+     * int16 parameters, and the record's own bytes for TEXT_INLINE.
+     */
+    class Slot(val type: Int, val color: Int, val width: Int, params: List<Int>, val text: ByteArray = ByteArray(0)) {
         val params: IntArray = IntArray(8) { params.getOrElse(it) { 0 } }
 
         override fun equals(other: Any?): Boolean =
             other is Slot && other.type == type && other.color == color && other.width == width &&
-                other.params.contentEquals(params)
+                other.params.contentEquals(params) && other.text.contentEquals(text)
 
-        override fun hashCode(): Int = ((type * 31 + color) * 31 + width) * 31 + params.contentHashCode()
+        override fun hashCode(): Int =
+            (((type * 31 + color) * 31 + width) * 31 + params.contentHashCode()) * 31 + text.contentHashCode()
     }
 
     class ElementState(val id: String, val contentHash: String, val slots: List<Slot>, val indices: List<Int>)
@@ -189,11 +209,15 @@ internal class G2CfwScene {
         return Triple(clampCoord(element.x + element.w / 2 + ox), clampCoord(element.y + element.h / 2 + oy), r)
     }
 
-    /** Slots for one element, or null when the texture cache cannot hold its content. */
+    /**
+     * Slots for one element, or null when the texture cache cannot hold its content.
+     * [inlineText] selects TEXT_INLINE records for default/builtin text.
+     */
     fun slotsFor(
         element: SceneElement,
         ox: Int,
         oy: Int,
+        inlineText: Boolean,
         cache: G2CfwTextureCache,
         rasterize: (SceneElement, Int, Int) -> ByteArray?,
     ): List<Slot>? {
@@ -245,13 +269,46 @@ internal class G2CfwScene {
                 val params = (0 until n).flatMap { point(element, it, ox, oy).toList() }
                 listOf(Slot(if (n == 3) TYPE_BEZIER2 else TYPE_BEZIER3, color, stroke(element), params))
             }
-            "text" -> if (element.font == "builtin") builtinTextSlots(element, x, y, cache)
-                      else rasterSlots(element, x, y, cache, rasterize)
+            "text" ->
+                when {
+                    element.font == "mono" -> rasterSlots(element, x, y, cache, rasterize)
+                    inlineText -> inlineTextSlots(element, x, y)
+                    element.font == "builtin" -> builtinTextSlots(element, x, y, cache)
+                    else -> rasterSlots(element, x, y, cache, rasterize)
+                }
             "image" -> rasterSlots(element, x, y, cache, rasterize)
             else -> emptyList()
         }
     }
 
+    /** One TEXT_INLINE slot per line, drawn by the glasses' font at the phone-raster 2 px inset, clipped to the box. */
+    private fun inlineTextSlots(element: SceneElement, x: Int, y: Int): List<Slot> {
+        val out = mutableListOf<Slot>()
+        val w = element.w.coerceIn(0, 2047)
+        val h = element.h.coerceIn(0, 2047)
+        if (element.border > 0) {
+            out.add(Slot(TYPE_RECT, gray(element), stroke(element), listOf(x, y, w, h, element.radius.coerceIn(0, 2047))))
+        }
+        val options = 0x10 or gray(element)
+        val maxLines = maxOf(1, element.h / TEXT_LINE_HEIGHT)
+        val lines = (element.text ?: "").split("\n").take(maxLines)
+        for ((index, line) in lines.withIndex()) {
+            val bytes = textBytes(line, MAX_INLINE_BYTES)
+            if (bytes.isEmpty()) continue
+            val lineY = y + TEXT_INSET + index * TEXT_LINE_HEIGHT
+            val clipW = maxOf(0, element.w - TEXT_INSET).coerceAtMost(2047)
+            val clipH = maxOf(0, element.h - TEXT_INSET - index * TEXT_LINE_HEIGHT).coerceAtMost(2047)
+            out.add(
+                Slot(
+                    TYPE_TEXT_INLINE, options, 0,
+                    listOf(clampCoord(x + TEXT_INSET), clampCoord(lineY), clipW, clipH, bytes.size),
+                    bytes,
+                ),
+            )
+        }
+        return out
+    }
+
     private fun builtinTextSlots(element: SceneElement, x: Int, y: Int, cache: G2CfwTextureCache): List<Slot>? {
         val out = mutableListOf<Slot>()
         if (element.border > 0) {
@@ -324,10 +381,11 @@ internal class G2CfwScene {
         originY: Int,
         cache: G2CfwTextureCache,
         rasterize: (SceneElement, Int, Int) -> ByteArray?,
+        inlineText: Boolean = false,
     ): Encoded? {
         val desired = mutableListOf<Desired>()
         for (element in frame.elements) {
-            val slots = slotsFor(element, originX, originY, cache, rasterize) ?: return null
+            val slots = slotsFor(element, originX, originY, inlineText, cache, rasterize) ?: return null
             desired.add(
                 Desired(element.id, element.contentHash, slots, transitionFrames(element.transitionMs), easingCurve(element.easing)),
             )

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

@@ -50,8 +50,8 @@ internal object G2FirmwareCatalog {
                 displayName = "Glassly CFW",
                 version = "2.2.9.22 CFW",
                 fileName = "g2-glassly-cfw-2.2.9.22.evenota.bin",
-                sha256 = "fe6051085507269c8007bc1245bfe8bd10d5c566540389ae976daaf753f536f9",
-                size = 4_527_476,
+                sha256 = "0c5990320d9f48fdca9b539be801f8f231f530fba286353c247dbe7911283f63",
+                size = 4_528_170,
             ),
         )