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

package/ios/Source/sgcs/G2.swift

@@ -1810,6 +1810,12 @@ final class G2: NSObject, SGCManager {
             .allSatisfy(cfwFeatures.contains)
     }
 
+    /// TEXT_INLINE records (contract revision 19; no token, the capability
+    /// response must fit one BLE frame): default text drawn by the glasses' font.
+    private var supportsCfwInlineText: Bool {
+        cfwProtocolVersion >= 19
+    }
+
     /// The on-glass slot table must be re-SET on the next vector frame.
     private var cfwSceneInvalid = true
 
@@ -3126,7 +3132,8 @@ final class G2: NSObject, SGCManager {
         }
         if cfwLastBoxes != boxes { cfwSceneInvalid = true }
         guard let encoded = await cfwRenderer.encodeVector(
-            frame, boxes: boxes, cacheGeneration: cfwCacheGeneration, invalidate: cfwSceneInvalid
+            frame, boxes: boxes, cacheGeneration: cfwCacheGeneration, invalidate: cfwSceneInvalid,
+            inlineText: supportsCfwInlineText
         ) else {
             Bridge.log("G2: vector scene does not fit; using the raster path for this frame")
             cfwSceneInvalid = true

package/ios/Source/sgcs/G2CfwRenderer.swift

@@ -68,7 +68,7 @@ actor G2CfwRenderer {
     /// `invalidate` forces a full re-SET (the on-glass slot table is unknown).
     /// Nil when the frame does not fit the slot table or the texture cache.
     func encodeVector(
-        _ frame: SceneFrame, boxes: LensBoxes, cacheGeneration: Int, invalidate: Bool
+        _ frame: SceneFrame, boxes: LensBoxes, cacheGeneration: Int, invalidate: Bool, inlineText: Bool
     ) -> G2CfwScene.Encoded? {
         if textureCache.generation != cacheGeneration || textureCache.exhausted {
             textureCache.reset(generation: cacheGeneration)
@@ -90,13 +90,15 @@ actor G2CfwRenderer {
         }
         let ox = Int(boxes.left.x)
         let oy = Int(boxes.left.y)
-        if let encoded = scene.encode(frame, originX: ox, originY: oy, cache: textureCache, rasterize: rasterize) {
+        if let encoded = scene.encode(frame, originX: ox, originY: oy, inlineText: inlineText,
+                                      cache: textureCache, rasterize: rasterize) {
             return encoded
         }
         // Out of texture cache mid-frame: start a fresh cache and repack once.
         textureCache.reset(generation: cacheGeneration)
         scene.reset(generation: cacheGeneration)
-        return scene.encode(frame, originX: ox, originY: oy, cache: textureCache, rasterize: rasterize)
+        return scene.encode(frame, originX: ox, originY: oy, inlineText: inlineText,
+                            cache: textureCache, rasterize: rasterize)
     }
 
     /// Fixed cell metrics of the phone's monospaced face at `fontSize`.

package/ios/Source/sgcs/G2CfwScene.swift

@@ -3,19 +3,22 @@ import Foundation
 /// 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.
 final class G2CfwScene {
     static let maxSlots = 128
     static let recordBytes = 20
     static let framePeriodMs = 33.0
     static let textLineHeight = 27
+    static let textInset = 2
     static let maxTextBytes = 64
+    static let maxInlineBytes = 128
     static let maxTileSize = 255
     /// Mode-13/15 options: identity ramp, transparent source color 0.
     static let textOptions: UInt8 = 0x1F
@@ -23,7 +26,7 @@ final class G2CfwScene {
 
     enum ShapeType: UInt8 {
         case line = 1, rect, rectFill, circle, circleFill, tri, triFill, quad, quadFill
-        case bezier2, bezier3, arc, pie, image, text, textCached
+        case bezier2, bezier3, arc, pie, image, text, textCached, textInline
     }
 
     struct Slot: Equatable {
@@ -31,14 +34,17 @@ final class G2CfwScene {
         var color: UInt8
         var width: UInt8
         var params: [Int16]
+        /// TEXT_INLINE bytes carried in the record.
+        var text: [UInt8]
 
-        init(_ type: ShapeType, color: UInt8, width: UInt8 = 0, _ params: [Int16]) {
+        init(_ type: ShapeType, color: UInt8, width: UInt8 = 0, _ params: [Int16], text: [UInt8] = []) {
             self.type = type.rawValue
             self.color = color
             self.width = width
             var padded = params
             while padded.count < 8 { padded.append(0) }
             self.params = Array(padded.prefix(8))
+            self.text = text
         }
     }
 
@@ -80,6 +86,7 @@ final class G2CfwScene {
         case .tri, .triFill, .bezier2: return 0x3F
         case .quad, .quadFill, .bezier3: return 0xFF
         case .image, .text, .textCached: return 0x03
+        case .textInline: return 0x0F
         case .none: return 0
         }
     }
@@ -124,8 +131,9 @@ final class G2CfwScene {
     }
 
     /// Slots for one element, or nil when the texture cache cannot hold its content.
+    /// `inlineText` selects TEXT_INLINE records for default/builtin text.
     func slots(
-        for element: SceneElement, originX ox: Int, originY oy: Int,
+        for element: SceneElement, originX ox: Int, originY oy: Int, inlineText: Bool,
         cache: G2CfwTextureCache, rasterize: (SceneElement, Int, Int) -> Data?
     ) -> [Slot]? {
         let x = Self.clampCoord(Int(element.x) + ox)
@@ -179,6 +187,10 @@ final class G2CfwScene {
                 params.append(contentsOf: [px, py])
             }
             return [Slot(n == 3 ? .bezier2 : .bezier3, color: color, width: Self.stroke(element), params)]
+        case "text" where element.font == "mono":
+            return rasterSlots(element, x: x, y: y, cache: cache, rasterize: rasterize)
+        case "text" where inlineText:
+            return inlineTextSlots(element, x: x, y: y)
         case "text" where element.font == "builtin":
             return builtinTextSlots(element, x: x, y: y, cache: cache)
         case "text", "image":
@@ -208,13 +220,40 @@ final class G2CfwScene {
         return out
     }
 
+    /// One TEXT_INLINE slot per line, drawn by the glasses' font at the same 2 px
+    /// inset as phone-rasterized text, clipped to the box.
+    private func inlineTextSlots(_ element: SceneElement, x: Int16, y: Int16) -> [Slot] {
+        var out: [Slot] = []
+        let w = Int16(max(0, min(2047, Int(element.w))))
+        let h = Int16(max(0, min(2047, Int(element.h))))
+        if element.border > 0 {
+            out.append(Slot(.rect, color: Self.gray(element), width: Self.stroke(element),
+                            [x, y, w, h, Int16(max(0, min(2047, Int(element.radius))))]))
+        }
+        let options = UInt8(0x10) | Self.gray(element)
+        let maxLines = max(1, Int(element.h) / Self.textLineHeight)
+        let lines = (element.text ?? "").split(separator: "\n", omittingEmptySubsequences: false).prefix(maxLines)
+        for (index, line) in lines.enumerated() {
+            let bytes = Self.textBytes(String(line), max: Self.maxInlineBytes)
+            if bytes.isEmpty { continue }
+            let lineY = Int(y) + Self.textInset + index * Self.textLineHeight
+            let clipW = max(0, Int(element.w) - Self.textInset)
+            let clipH = max(0, Int(element.h) - Self.textInset - index * Self.textLineHeight)
+            out.append(Slot(.textInline, color: options,
+                            [Self.clampCoord(Int(x) + Self.textInset), Self.clampCoord(lineY),
+                             Int16(min(2047, clipW)), Int16(min(2047, clipH)), Int16(bytes.count)],
+                            text: bytes))
+        }
+        return out
+    }
+
     /// UTF-8 bytes of a line without firmware control bytes (1..31), cut at a codepoint boundary.
-    static func textBytes(_ line: String) -> [UInt8] {
+    static func textBytes(_ line: String, max limit: Int = maxTextBytes) -> [UInt8] {
         let cleaned = line.unicodeScalars.filter { $0.value >= 32 }
         var bytes: [UInt8] = []
         for scalar in cleaned {
             let encoded = Array(String(scalar).utf8)
-            if bytes.count + encoded.count > maxTextBytes { break }
+            if bytes.count + encoded.count > limit { break }
             bytes.append(contentsOf: encoded)
         }
         return bytes
@@ -256,8 +295,8 @@ final class G2CfwScene {
     /// that must precede it. Nil when the frame does not fit the slot table or
     /// the texture cache; the caller then falls back to the raster path.
     func encode(
-        _ frame: SceneFrame, originX: Int, originY: Int, cache: G2CfwTextureCache,
-        rasterize: (SceneElement, Int, Int) -> Data?
+        _ frame: SceneFrame, originX: Int, originY: Int, inlineText: Bool = false,
+        cache: G2CfwTextureCache, rasterize: (SceneElement, Int, Int) -> Data?
     ) -> Encoded? {
         struct Desired {
             let id: String
@@ -268,7 +307,8 @@ final class G2CfwScene {
         }
         var desired: [Desired] = []
         for element in frame.elements {
-            guard let slots = slots(for: element, originX: originX, originY: originY, cache: cache, rasterize: rasterize)
+            guard let slots = slots(for: element, originX: originX, originY: originY, inlineText: inlineText,
+                                    cache: cache, rasterize: rasterize)
             else { return nil }
             desired.append(Desired(
                 id: element.id, contentHash: element.contentHash, slots: slots,
@@ -347,21 +387,27 @@ final class G2CfwScene {
         return Encoded(payload: payload, uploads: cache.takeUploadPayloads())
     }
 
-    /// `[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]`.
     static func setRecord(_ slot: Slot, index: UInt8) -> Data {
         var out = Data([0, index, slot.type, 1, slot.color, slot.width])
-        for value in slot.params {
+        let count = slot.type == ShapeType.textInline.rawValue ? 4 : 8
+        for value in slot.params.prefix(count) {
             let bits = UInt16(bitPattern: value)
             out.append(UInt8(bits & 0xFF))
             out.append(UInt8(bits >> 8))
         }
+        if slot.type == ShapeType.textInline.rawValue {
+            out.append(UInt8(min(slot.text.count, maxInlineBytes)))
+            out.append(contentsOf: slot.text.prefix(maxInlineBytes))
+        }
         return out
     }
 
     /// `[5][slot][mask:u16][frames][curve x4][value:i16 per set bit]`, or nil when the
     /// change is not a pure geometry/stroke change of the same shape type.
     static func tweenRecord(from old: Slot, to new: Slot, index: UInt8, frames: UInt8, curve: [UInt8]) -> Data? {
-        guard old.type == new.type else { return nil }
+        guard old.type == new.type, old.text == new.text else { return nil }
         let tweenable = tweenableMask(new.type)
         var mask: UInt16 = 0
         var values: [Int16] = []
@@ -372,7 +418,9 @@ final class G2CfwScene {
         }
         let isTexture = new.type >= ShapeType.image.rawValue
         if old.color != new.color {
-            guard !isTexture else { return nil }
+            // Inline text may fade (low nibble) as long as its option bits stay put.
+            let inlineFade = new.type == ShapeType.textInline.rawValue && (old.color & 0xF0) == (new.color & 0xF0)
+            guard !isTexture || inlineFade else { return nil }
             mask |= 0x100
             values.append(Int16(new.color))
         }

package/ios/Source/sgcs/G2Flasher.swift

@@ -37,8 +37,8 @@ enum 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
         ),
     ]
 

package/ios/Tests/BluetoothSDKTests/DisplayPacerTests.swift

@@ -0,0 +1,255 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+@MainActor
+final class DisplayPacerTests: XCTestCase {
+    @MainActor private final class Harness {
+        var now: Int64 = 1000
+        var delay: Int64?
+        var block: (@MainActor () -> Void)?
+        var scheduled = 0
+        var scenes: [SceneFrame] = []
+        var legacySends = 0
+        var pacer: DisplayPacer!
+
+        init(fps: Int = 8) {
+            pacer = DisplayPacer(
+                dispatchScene: { [unowned self] in self.scenes.append($0) },
+                sendLegacy: { [unowned self] in self.legacySends += 1 },
+                clock: { [unowned self] in self.now },
+                scheduler: { [unowned self] delayMs, block in
+                    self.scheduled += 1
+                    self.delay = delayMs
+                    self.block = block
+                    let token = self.scheduled
+                    return {
+                        if self.scheduled == token {
+                            self.block = nil
+                            self.delay = nil
+                        }
+                    }
+                }
+            )
+            pacer.setMaxFps(fps)
+        }
+
+        func fire() {
+            guard let b = block else { XCTFail("no timer armed"); return }
+            block = nil
+            delay = nil
+            b()
+        }
+    }
+
+    private func element(_ id: String, change: String = "created", x: Int32 = 0) -> SceneElement {
+        SceneElement(
+            id: id, type: "text", x: x, y: 0, w: 10, h: 10, text: id, data: nil, border: 0, radius: 0,
+            change: change, contentHash: "h-\(id)"
+        )
+    }
+
+    private func frame(
+        _ elements: [SceneElement], removed: [String] = [], appId: String = "app", replay: Bool = false,
+        epoch: Int = 1
+    ) -> SceneFrame {
+        SceneFrame(appId: appId, epoch: epoch, replay: replay, elements: elements, removed: removed)
+    }
+
+    private func change(_ frame: SceneFrame, _ id: String) -> String? {
+        frame.elements.first { $0.id == id }?.change
+    }
+
+    func testFirstSubmitSendsImmediately() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testSecondSubmitInsideWindowIsHeldUntilTheSlot() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 30
+        h.pacer.submitScene(frame([element("a", change: "updated")], epoch: 2))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.delay, 70)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(h.scenes[1].epoch, 2)
+    }
+
+    func testRapidFramesCoalesceIntoOneMergedSend() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")], epoch: 2))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "moved", x: 5)], epoch: 3))
+        h.now += 10
+        h.pacer.submitScene(
+            frame([element("a", change: "unchanged"), element("b", change: "unchanged", x: 5)], epoch: 4)
+        )
+        XCTAssertEqual(h.scheduled, 1)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.epoch, 4)
+        XCTAssertEqual(change(sent, "a"), "updated")
+        XCTAssertEqual(change(sent, "b"), "created")
+        XCTAssertEqual(sent.elements.first { $0.id == "b" }?.x, 5)
+    }
+
+    func testUpdatedThenUnchangedBecomesUpdated() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "moved", x: 3)]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged", x: 3)]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+    }
+
+    func testRemovedThenRecreatedIdIsNotRemoved() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "created")]))
+        h.now += 200
+        h.fire()
+        XCTAssertTrue(h.scenes[1].removed.isEmpty)
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+    }
+
+    func testPendingRemovesSurviveIntoTheMergedFrame() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b"), element("c")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b", "c"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["c"]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes[1].removed, ["b", "c"])
+    }
+
+    func testAppSwitchDiscardsPending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")], removed: ["z"], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("b", change: "created")], appId: "two", replay: true))
+        h.now += 200
+        h.fire()
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.appId, "two")
+        XCTAssertTrue(sent.removed.isEmpty)
+        XCTAssertEqual(sent.elements.map(\.id), ["b"])
+    }
+
+    func testEmptyFrameFlushesImmediatelyWithPendingRemoves() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.flushScene(frame([], removed: ["a"]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(Set(h.scenes[1].removed), ["a", "b"])
+        XCTAssertTrue(h.scenes[1].elements.isEmpty)
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testClearViewFlushesImmediatelyAndDropsPendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertNotNil(h.block)
+        h.pacer.flushLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLegacyAfterSceneDropsThePendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.legacySends, 1)
+    }
+
+    func testSceneAfterLegacyDropsThePendingLegacy() {
+        let h = Harness()
+        h.pacer.submitLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 1
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+    }
+
+    func testSetMaxFpsRearmsAPendingTimer() {
+        let h = Harness(fps: 2)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 50
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 450)
+        h.pacer.setMaxFps(20)
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertNil(h.block)
+
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 40)
+        h.pacer.setMaxFps(10)
+        XCTAssertEqual(h.delay, 90)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testCancelDropsPendingWithoutSending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.pacer.cancel()
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLateSubmitAfterTheSlotSendsMergedImmediately() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")]))
+        h.now += 200
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "unchanged")]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+        XCTAssertNil(h.block)
+    }
+}

package/ios/Tests/BluetoothSDKTests/G2CfwSceneTests.swift

@@ -21,8 +21,9 @@ final class G2CfwSceneTests: XCTestCase {
     }
 
     private func encode(_ scene: G2CfwScene, _ cache: G2CfwTextureCache, _ elements: [SceneElement],
-                        replay: Bool = false) -> G2CfwScene.Encoded? {
-        scene.encode(frame(elements, replay: replay), originX: 32, originY: 96, cache: cache) { el, w, h in
+                        replay: Bool = false, inlineText: Bool = false) -> G2CfwScene.Encoded? {
+        scene.encode(frame(elements, replay: replay), originX: 32, originY: 96, inlineText: inlineText,
+                     cache: cache) { el, w, h in
             Data(repeating: 0xFF, count: w * h)
         }
     }
@@ -184,4 +185,47 @@ final class G2CfwSceneTests: XCTestCase {
         XCTAssertEqual(G2CfwScene.transitionFrames(ms: 60000), 255)
         XCTAssertEqual(G2CfwScene.easingCurve("ease-in-out"), [107, 0, 148, 255])
     }
+
+    func testInlineTextRecordsCarryTheirBytesAndAnimate() throws {
+        let scene = G2CfwScene()
+        let cache = G2CfwTextureCache()
+        cache.reset(generation: 1)
+        scene.reset(generation: 1)
+        let first = try XCTUnwrap(encode(scene, cache, [
+            element("t", type: "text", x: 10, y: 10, w: 200, h: 60, text: "hi\nthere", color: 9),
+            element("m", type: "text", x: 0, y: 200, w: 100, h: 30, text: "grid", font: "mono", hash: "mono"),
+        ], inlineText: true))
+        XCTAssertEqual(first.uploads.count, 1)                       // only the mono raster hits the cache
+        XCTAssertEqual(scene.elements.map(\.indices), [[0, 1], [2]])
+        let bytes = [UInt8](first.payload)
+        // slot 0: TEXT_INLINE, transparent + gray 9, x/y inset by 2, clip to the box, "hi"
+        XCTAssertEqual(Array(bytes[3 ..< 9]), [0, 0, 17, 1, 0x19, 0])
+        XCTAssertEqual(Array(bytes[9 ..< 17]), le(44, 108, 198, 58))
+        XCTAssertEqual(Array(bytes[17 ..< 20]), [2, 0x68, 0x69])
+        // slot 1 follows immediately: 13 + 2 bytes after the first record
+        XCTAssertEqual(Array(bytes[20 ..< 23]), [0, 1, 17])
+        XCTAssertEqual(Array(bytes[26 ..< 34]), le(44, 135, 198, 31))
+        XCTAssertEqual(Array(bytes[35 ..< 40]), Array("there".utf8))
+        XCTAssertEqual(bytes[40], 0)                                  // mono raster SET
+        XCTAssertEqual(bytes[42], 14)
+
+        // a new string is a SET even with a transition; a move alone tweens; a fade tweens the color
+        let moved = try XCTUnwrap(encode(scene, cache, [
+            element("t", type: "text", x: 10, y: 40, w: 200, h: 60, text: "hi\nthere", color: 9, transitionMs: 330),
+            element("m", type: "text", x: 0, y: 200, w: 100, h: 30, text: "grid", font: "mono", hash: "mono"),
+        ], inlineText: true))
+        XCTAssertEqual(Array([UInt8](moved.payload)[3 ..< 8]), [5, 0, 0x02, 0x00, 10])
+        let retexted = try XCTUnwrap(encode(scene, cache, [
+            element("t", type: "text", x: 10, y: 40, w: 200, h: 60, text: "ho\nthere", color: 9, transitionMs: 330),
+            element("m", type: "text", x: 0, y: 200, w: 100, h: 30, text: "grid", font: "mono", hash: "mono"),
+        ], inlineText: true))
+        XCTAssertEqual(Array([UInt8](retexted.payload)[3 ..< 6]), [0, 0, 17])
+        let faded = try XCTUnwrap(encode(scene, cache, [
+            element("t", type: "text", x: 10, y: 40, w: 200, h: 60, text: "ho\nthere", color: 3, transitionMs: 330),
+            element("m", type: "text", x: 0, y: 200, w: 100, h: 30, text: "grid", font: "mono", hash: "mono"),
+        ], inlineText: true))
+        let fade = [UInt8](faded.payload)
+        XCTAssertEqual(Array(fade[3 ..< 8]), [5, 0, 0x00, 0x01, 10])
+        XCTAssertEqual(Array(fade[12 ..< 14]), le(0x13))
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassly/bluetooth-sdk",
-  "version": "0.1.0-dev.112",
+  "version": "0.1.0-dev.114",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.1.0",
-  "releaseIdentity": "0.1.0-dev.112",
-  "releaseSetId": "glassly-0.1.0-dev.112",
-  "sourceCommit": "385c3de9054122bf005790a6b1faf04d3117d512",
+  "releaseIdentity": "0.1.0-dev.114",
+  "releaseSetId": "glassly-0.1.0-dev.114",
+  "sourceCommit": "17263133b35c04f044ba0d3acd9f80efc81999d4",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })