@glassly/bluetooth-sdk 0.1.0-dev.61 → 0.1.0-dev.89

package/ios/Source/sgcs/G2.swift

@@ -44,6 +44,14 @@ private enum G2BLE {
     static let CHAR_WRITE = CBUUID(string: "00002760-08C2-11E1-9073-0E8AC72E5401")
     static let CHAR_NOTIFY = CBUUID(string: "00002760-08C2-11E1-9073-0E8AC72E5402")
     static let AUDIO_NOTIFY = CBUUID(string: "00002760-08C2-11E1-9073-0E8AC72E6402")
+    // File-transfer characteristics (notification JSON / whitelist pushes ride
+    // the 0xC4/0xC5 file services here, not the main 5401 protocol char)
+    static let FILE_WRITE = CBUUID(string: "00002760-08C2-11E1-9073-0E8AC72E7401")
+    static let FILE_NOTIFY = CBUUID(string: "00002760-08C2-11E1-9073-0E8AC72E7402")
+
+    // File-transfer service IDs (same AA-21 envelope as every other service)
+    static let FILE_SERVICE_CMD: UInt8 = 0xC4 // FILE_CHECK header, START (0x01), END (0x02)
+    static let FILE_SERVICE_DATA: UInt8 = 0xC5 // raw file bytes
 
     /// We discover services by scanning for these characteristics
     /// The service UUID that contains these chars
@@ -136,6 +144,14 @@ private enum G2SettingCommandId: Int32 {
     case deviceRespondToApp = 4 // Glasses responds to app
 }
 
+/// eNotificationCommandId from notification.proto (service 0x04)
+private enum NotificationCmd: Int32 {
+    case ctrl = 1 // NOTIFICATION_CTRL — NotificationControl in field 3
+    case ios = 2 // NOTIFICATION_IOS — glasses report an ANCS source app in field 4
+    case whitelistCtrl = 3 // NOTIFICATION_WHITELIST_CTRL — NotificationWhitelistCtrl in field 6
+    case commRsp = 161 // NOTIFICATION_COMM_RSP
+}
+
 /// DevCfgCommandId from dev_config_protocol.proto
 private enum DevCfgCommandId: Int32 {
     case authentication = 4
@@ -1608,7 +1624,9 @@ private final class ImgAckBox {
         self.session = nil
         self.fragment = nil
         cont = nil
-        if success { lastSuccessMs = Int64(Date().timeIntervalSince1970 * 1000) }
+        if success {
+            lastSuccessMs = Int64(Date().timeIntervalSince1970 * 1000)
+        }
         lock.unlock()
         c.resume(returning: success)
         return true
@@ -1699,7 +1717,7 @@ final class G2: NSObject, SGCManager {
     private var cfwSceneActive = false
     /// Rate limit on resurrecting the page for a blank scene; a non-blank one rebuilds immediately.
     private var cfwLastIdleResurrectAt: Date?
-    private static let cfwIdleResurrectMinIntervalMs: Double = 5_000
+    private static let cfwIdleResurrectMinIntervalMs: Double = 5000
     private static let cfwSceneContainerID: Int32 = 10
     private let cfwRenderer = G2CfwRenderer()
     /// Deltas composite onto a shadow seeded by a mode-6 keyframe, so payloads drain in order.
@@ -1762,13 +1780,20 @@ final class G2: NSObject, SGCManager {
 
     /// Mode-9 rect copies have no capability token; they shipped with
     /// protocol revision 15 alongside the texture/font modes.
-    private var supportsCfwRectCopy: Bool { cfwProtocolVersion >= 15 }
+    private var supportsCfwRectCopy: Bool {
+        cfwProtocolVersion >= 15
+    }
+
     /// Mode-15 builtin-font string draws (`font15` capability token).
-    private var supportsCfwBuiltinText: Bool { cfwFeatures.contains("font15") }
+    private var supportsCfwBuiltinText: Bool {
+        cfwFeatures.contains("font15")
+    }
+
     /// Mode-12 uploads + mode-14 cached-glyph runs (mono text as draws).
     private var supportsCfwTextureGlyphs: Bool {
         cfwFeatures.contains("texcache12") && cfwFeatures.contains("texstr14")
     }
+
     /// Mode-12 uploads + mode-13 cached-image draws (repeated icons as draws).
     private var supportsCfwTextureImages: Bool {
         cfwFeatures.contains("texcache12") && cfwFeatures.contains("teximg13")
@@ -1787,6 +1812,10 @@ final class G2: NSObject, SGCManager {
     private var rightNotifyChar: CBCharacteristic?
     private var rightAudioChar: CBCharacteristic?
     private var leftAudioChar: CBCharacteristic?
+    private var leftFileWriteChar: CBCharacteristic?
+    private var rightFileWriteChar: CBCharacteristic?
+    private var leftFileNotifyChar: CBCharacteristic?
+    private var rightFileNotifyChar: CBCharacteristic?
     private var leftInitialized: Bool = false
     private var rightInitialized: Bool = false
     private var leftAuthenticated: Bool = false
@@ -1813,6 +1842,15 @@ final class G2: NSObject, SGCManager {
     // and is dropped entirely — see the SysEvent handler.
     private let PHANTOM_EXIT_ACK_WINDOW_MS: Int64 = 2500
 
+    /// Shared connect options. RequiresANCS raises the iOS "Share System
+    /// Notifications" consent so the glasses' on-firmware ANCS client can read
+    /// the phone's notification stream (the phone app itself never can).
+    private static let peripheralConnectOptions: [String: Any] = [
+        CBConnectPeripheralOptionNotifyOnConnectionKey: true,
+        CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
+        CBConnectPeripheralOptionRequiresANCS: true,
+    ]
+
     /// Device search
     var DEVICE_SEARCH_ID = "NOT_SET"
     /// map device names to serial numbers:
@@ -2415,6 +2453,12 @@ final class G2: NSObject, SGCManager {
         let calendarEvents =
             DeviceStore.shared.get("bluetooth", "calendar_events") as? [[String: Any]] ?? []
         sendCalendarEvents(calendarEvents)
+
+        // push ANCS notification config (display options + app filter) and
+        // surface the current ANCS authorization state to the UI
+        publishAncsAuthorization()
+        sendNotificationCtrl()
+        sendNotificationFilter()
     }
 
     // MARK: - Heartbeats
@@ -2521,6 +2565,106 @@ final class G2: NSObject, SGCManager {
         setDashboardMenu(menuItems)
     }
 
+    // MARK: - Notifications (on-glass ANCS display options + app filter)
+
+    /// Push NotificationControl (master toggle, auto-display popup, on-screen
+    /// duration, avoid-disturb) from the DeviceStore `notification_ctrl` dict.
+    /// Full state is retransmitted on every change — that matches the stock app
+    /// and the glasses echo it back as the ack.
+    func sendNotificationCtrl() {
+        let ctrl = DeviceStore.shared.get("bluetooth", "notification_ctrl") as? [String: Any] ?? [:]
+        let enabled = ctrl["enabled"] as? Bool ?? true
+        let autoDisplay = ctrl["auto_display"] as? Bool ?? true
+        let dispTime = ctrl["disp_time"] as? Int ?? 5
+        let avoidDisturb = ctrl["avoid_disturb"] as? Bool ?? true
+
+        var ctrlW = ProtobufWriter()
+        ctrlW.writeInt32Field(1, enabled ? 1 : 0) // notifEnable
+        ctrlW.writeInt32Field(2, autoDisplay ? 1 : 0) // autoDispEnable
+        ctrlW.writeInt32Field(3, Int32(dispTime)) // dispTime (0/5/7/10 s)
+        ctrlW.writeInt32Field(5, avoidDisturb ? 1 : 0) // avoidDisturbEnable
+
+        var pkg = ProtobufWriter()
+        pkg.writeInt32Field(1, NotificationCmd.ctrl.rawValue)
+        pkg.writeInt32Field(2, sendManager.nextMagicRandom())
+        pkg.writeMessageField(3, ctrlW.data)
+        sendNotificationCommand(pkg.data)
+        Bridge.log(
+            "G2: Sent notification ctrl enabled=\(enabled) autoDisplay=\(autoDisplay) dispTime=\(dispTime) avoidDisturb=\(avoidDisturb)"
+        )
+    }
+
+    /// Push the ANCS app allowlist from the DeviceStore `notification_filter`
+    /// dict ({enabled, apps: [{id, name}]}). The list travels as the
+    /// `user/notify_whitelist.json` file (the protobuf whitelist message only
+    /// carries the enable toggle); the WHITELIST_CTRL toggle goes after the
+    /// file so the firmware reloads with the new list in place.
+    func sendNotificationFilter() {
+        let filter = DeviceStore.shared.get("bluetooth", "notification_filter") as? [String: Any] ?? [:]
+        let enabled = filter["enabled"] as? Bool ?? false
+        let apps = filter["apps"] as? [[String: Any]] ?? []
+        Task { [weak self] in
+            await self?.pushNotificationFilter(enabled: enabled, apps: apps)
+        }
+    }
+
+    private func pushNotificationFilter(enabled: Bool, apps: [[String: Any]]) async {
+        let entries = apps.compactMap { app -> (id: String, name: String)? in
+            guard let id = app["id"] as? String, !id.isEmpty else { return nil }
+            return (id: id, name: app["name"] as? String ?? id)
+        }
+        // The file is written even when filtering is off so a later enable
+        // toggles against the user's current list, not a stale one.
+        let json = G2NotifyFile.whitelistJson(filterEnabled: enabled, apps: entries)
+        await sendNotifyFile(named: G2NotifyFile.whitelistFilename, content: json)
+
+        var wlW = ProtobufWriter()
+        wlW.writeInt32Field(1, enabled ? 0 : 1) // whitelistDisable (disabled = fail-open)
+        var pkg = ProtobufWriter()
+        pkg.writeInt32Field(1, NotificationCmd.whitelistCtrl.rawValue)
+        pkg.writeInt32Field(2, sendManager.nextMagicRandom())
+        pkg.writeMessageField(6, wlW.data)
+        sendNotificationCommand(pkg.data)
+        Bridge.log("G2: Sent notification filter enabled=\(enabled) apps=\(entries.count)")
+    }
+
+    /// File-transfer push (services 0xC4/0xC5 on the dedicated file
+    /// characteristic): FILE_CHECK header → START → DATA → END, per arm. The
+    /// glasses cache by checksum but still expect the data packets either way,
+    /// so no branching on the CACHE_HIT/MISS response is needed.
+    private func sendNotifyFile(named filename: String, content: Data) async {
+        guard !firmwareFlashLifecycleActive, !firmwareFlasher.isActive else { return }
+        let header = G2NotifyFile.fileCheckHeader(filename: filename, content: content)
+        var pushedSides: [String] = []
+        for right in [true, false] {
+            guard let peripheral = right ? rightPeripheral : leftPeripheral,
+                  let char = right ? rightFileWriteChar : leftFileWriteChar
+            else { continue }
+            let writeType: CBCharacteristicWriteType =
+                char.properties.contains(.writeWithoutResponse) ? .withoutResponse : .withResponse
+
+            func write(_ packets: [Data]) async {
+                for packet in packets {
+                    peripheral.writeValue(packet, for: char, type: writeType)
+                    try? await Task.sleep(nanoseconds: 8_000_000)
+                }
+            }
+
+            await write(sendManager.buildPackets(serviceId: G2BLE.FILE_SERVICE_CMD, payload: header))
+            try? await Task.sleep(nanoseconds: 150_000_000)
+            await write(sendManager.buildPackets(serviceId: G2BLE.FILE_SERVICE_CMD, payload: Data([0x01]))) // START
+            try? await Task.sleep(nanoseconds: 50_000_000)
+            await write(sendManager.buildPackets(serviceId: G2BLE.FILE_SERVICE_DATA, payload: content))
+            try? await Task.sleep(nanoseconds: 50_000_000)
+            await write(sendManager.buildPackets(serviceId: G2BLE.FILE_SERVICE_CMD, payload: Data([0x02]))) // END
+            try? await Task.sleep(nanoseconds: 50_000_000)
+            pushedSides.append(right ? "R" : "L")
+        }
+        Bridge.log(
+            "G2: Pushed \(filename) (\(content.count) bytes) to [\(pushedSides.joined(separator: ","))]"
+        )
+    }
+
     // MARK: - SGCManager: Display Control
 
     func sendTextWall(_ text: String) async {
@@ -2855,7 +2999,8 @@ final class G2: NSObject, SGCManager {
                 // hatch may have been flipped off mid-session — without this
                 // check the lease renews forever while frames go stock.
                 if self.cfwSceneActive, self.pageCreated, self.dashboardShowing == 0,
-                   self.supportsCfwSceneRendering {
+                   self.supportsCfwSceneRendering
+                {
                     self.sendFaceclawFbControl(acquire: true)
                 } else {
                     self.stopFbLease(sendRelease: true)
@@ -2868,7 +3013,9 @@ final class G2: NSObject, SGCManager {
     private func stopFbLease(sendRelease: Bool) {
         fbLeaseTask?.cancel()
         fbLeaseTask = nil
-        if sendRelease { sendFaceclawFbControl(acquire: false) }
+        if sendRelease {
+            sendFaceclawFbControl(acquire: false)
+        }
         // Lease end frees the on-glass texture cache; the model must re-learn.
         cfwCacheGeneration += 1
     }
@@ -2879,7 +3026,11 @@ final class G2: NSObject, SGCManager {
     /// expire) restores stock behavior and launches any deferred dashboard.
     func wakeLeaseEnabled(_ enabled: Bool) {
         wakeLeaseWanted = enabled
-        if enabled { startWakeLease() } else { stopWakeLease(sendRelease: true) }
+        if enabled {
+            startWakeLease()
+        } else {
+            stopWakeLease(sendRelease: true)
+        }
     }
 
     /// Like the fb lease, the wake lease is per lens and must reach both arms.
@@ -2908,7 +3059,9 @@ final class G2: NSObject, SGCManager {
     private func stopWakeLease(sendRelease: Bool) {
         wakeLeaseTask?.cancel()
         wakeLeaseTask = nil
-        if sendRelease { sendFaceclawWakeControl(acquire: false) }
+        if sendRelease {
+            sendFaceclawWakeControl(acquire: false)
+        }
     }
 
     /// The firmware lease is volatile and dies with the link, while
@@ -2951,11 +3104,28 @@ final class G2: NSObject, SGCManager {
         let textDraws = useBuiltinText ? G2CfwRenderer.builtinTextDraws(frame, boxes: boxes) : []
         // Text pixels are never in the raster: force old + new bounds dirty so stale glyphs erase.
         var forced: [G2CfwRenderer.CanvasRect] = []
+        var marginBlank: G2CfwRenderer.LensBoxes?
         if textDraws != cfwLastTextDraws {
             forced = G2CfwRenderer.builtinTextBounds(
                 cfwLastTextDraws + textDraws, boxes: boxes,
                 canvasWidth: Int(boxes.width), canvasHeight: Int(boxes.height)
             )
+            // Mode 15 doesn't clip at the window's right edge: a line the
+            // phone's metrics under-measured can spill into the outer panel
+            // margin, where no in-window rect or full frame ever repaints.
+            // Blank the old window's right margin whenever draws change.
+            // (Builtin frames pin depth, so the old window is lens-equal.)
+            if !cfwLastTextDraws.isEmpty, let last = cfwLastBoxes, last.left == last.right {
+                let edgeX = Int32(last.left.x) + last.width
+                let bandW = Int32(G2CfwRenderer.frameWidth) - edgeX
+                if bandW >= 4 {
+                    marginBlank = G2CfwRenderer.LensBoxes(
+                        left: CGPoint(x: CGFloat(edgeX), y: last.left.y),
+                        right: CGPoint(x: CGFloat(edgeX), y: last.right.y),
+                        width: bandW, height: last.height
+                    )
+                }
+            }
         }
         let fids = (0 ..< G2CfwRenderer.requiredFidCount).map { _ in nextCfwFrameId() }
         // Copies would smear firmware-drawn glyphs the raster knows nothing about.
@@ -2966,6 +3136,7 @@ final class G2: NSObject, SGCManager {
             forcedRects: forced, fids: fids, textDraws: textDraws,
             allowRectCopy: allowCopy,
             blankBoxes: movedBoxes ? cfwLastBoxes : nil,
+            marginBlankBoxes: marginBlank,
             omitBuiltinText: useBuiltinText,
             textureGlyphsEnabled: useTextureGlyphs,
             textureImagesEnabled: supportsCfwTextureImages && pinDepth,
@@ -3030,7 +3201,9 @@ final class G2: NSObject, SGCManager {
     /// whether they need a page rebuild.
     @discardableResult
     private func installCfwCarrierIfNeeded() -> Bool {
-        if textContainers.isEmpty && hasCfwCarrier { return true }
+        if textContainers.isEmpty && hasCfwCarrier {
+            return true
+        }
         textContainers.removeAll()
         sceneTextByElement.removeAll()
         sceneImageByElement.removeAll()
@@ -3093,7 +3266,9 @@ final class G2: NSObject, SGCManager {
         // its normal paths.
         guard cfwClassified, cfwCapabilityString != nil else { return }
         if enabled {
-            if installCfwCarrierIfNeeded() { return } // already the carrier page
+            if installCfwCarrierIfNeeded() {
+                return
+            } // already the carrier page
             Bridge.log("G2: cfw_scene_renderer ON — swapping stock containers for the CFW carrier")
             await requestPageRebuild()
         } else {
@@ -3381,7 +3556,9 @@ final class G2: NSObject, SGCManager {
             // the idle state is the same page everywhere.
             let carrierWasConfigured = installCfwCarrierIfNeeded()
             cfwClear()
-            if !carrierWasConfigured || !pageCreated { signalDisplayDirty() }
+            if !carrierWasConfigured || !pageCreated {
+                signalDisplayDirty()
+            }
             if !carrierWasConfigured, pageCreated {
                 // The live on-glass page still holds the stock containers the
                 // carrier just replaced locally (legacy text drawn before CFW
@@ -3728,7 +3905,9 @@ final class G2: NSObject, SGCManager {
                     if ok {
                         Bridge.log("G2: page-down probe acked — phantom exit, page alive (no rebuild)")
                         pageCreated = true
-                        if !cfwPendingPayloads.isEmpty { cfwPendingPayloads.removeFirst() }
+                        if !cfwPendingPayloads.isEmpty {
+                            cfwPendingPayloads.removeFirst()
+                        }
                         signalDisplayDirty() // drain the rest normally
                         return
                     }
@@ -3778,7 +3957,9 @@ final class G2: NSObject, SGCManager {
                     // loop (rebuild→systemExit→rebuild every debounce tick).
                     if pageCreated, supportsCfwSceneRendering, hasCfwCarrier {
                         cfwResetShadow()
-                        if let frame = cfwLastFrame { _ = await enqueueCfwFrame(frame) }
+                        if let frame = cfwLastFrame {
+                            _ = await enqueueCfwFrame(frame)
+                        }
                     }
                     break
                 }
@@ -4721,6 +4902,10 @@ final class G2: NSObject, SGCManager {
         rightNotifyChar = nil
         rightAudioChar = nil
         leftAudioChar = nil
+        leftFileWriteChar = nil
+        rightFileWriteChar = nil
+        leftFileNotifyChar = nil
+        rightFileNotifyChar = nil
         DEVICE_SEARCH_ID = "NOT_SET"
         centralManager?.delegate = nil
     }
@@ -4859,10 +5044,12 @@ final class G2: NSObject, SGCManager {
     }
 
     func dbg2() {
-
         Task {
+            dashboardShowing = 1
+            dashboardOpening = true
             let msg = EvenHubProto.shutdownMessage()
             sendEvenHubCommand(msg)
+            pageCreated = false
             try? await Task.sleep(nanoseconds: 300_000_000) // 300ms to settle
             await showNotificationsPanel()
         }
@@ -5308,6 +5495,10 @@ final class G2: NSObject, SGCManager {
         rightNotifyChar = nil
         leftAudioChar = nil
         rightAudioChar = nil
+        leftFileWriteChar = nil
+        rightFileWriteChar = nil
+        leftFileNotifyChar = nil
+        rightFileNotifyChar = nil
         authStarted = false
         leftAuthenticated = false
         rightAuthenticated = false
@@ -5383,10 +5574,7 @@ final class G2: NSObject, SGCManager {
                     device.discoverServices([G2BLE.SERVICE_UUID])
                     centralManager!.connect(
                         leftPeripheral!,
-                        options: [
-                            CBConnectPeripheralOptionNotifyOnConnectionKey: true,
-                            CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
-                        ]
+                        options: G2.peripheralConnectOptions
                     )
                 } else if name.contains("_R_") && serialNumber.contains(DEVICE_SEARCH_ID) {
                     rightPeripheral = device
@@ -5394,10 +5582,7 @@ final class G2: NSObject, SGCManager {
                     device.discoverServices([G2BLE.SERVICE_UUID])
                     centralManager!.connect(
                         rightPeripheral!,
-                        options: [
-                            CBConnectPeripheralOptionNotifyOnConnectionKey: true,
-                            CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
-                        ]
+                        options: G2.peripheralConnectOptions
                     )
                 }
                 // we can't emit the serial number here unfortunately:
@@ -5461,8 +5646,8 @@ final class G2: NSObject, SGCManager {
         rightPeripheral = right
         left.delegate = self
         right.delegate = self
-        centralManager?.connect(left, options: nil)
-        centralManager?.connect(right, options: nil)
+        centralManager?.connect(left, options: G2.peripheralConnectOptions)
+        centralManager?.connect(right, options: G2.peripheralConnectOptions)
         return true
     }
 
@@ -5602,31 +5787,39 @@ final class G2: NSObject, SGCManager {
         // path Android's NotificationListenerService feeds. iOS can't read
         // other apps' notifications, but the glasses CAN (ANCS) and report the
         // source app here; title/content are empty because this packet only
-        // carries app identity.
-        // commented out as this is borderline useless without content
-        // if cmd == 2, let iosData = fields[4] as? Data {
-        //     var ios = ProtobufReader(iosData)
-        //     let iosFields = ios.parseFields()
-        //     let appID = (iosFields[1] as? Data).flatMap { String(data: $0, encoding: .utf8) }?
-        //         .trimmingCharacters(in: CharacterSet(charactersIn: "\0")) ?? ""
-        //     let name = (iosFields[2] as? Data).flatMap { String(data: $0, encoding: .utf8) }?
-        //         .trimmingCharacters(in: CharacterSet(charactersIn: "\0")) ?? ""
-        //     if !appID.isEmpty {
-        //         let now = Int64(Date().timeIntervalSince1970 * 1000)
-        //         Bridge.sendTypedMessage(
-        //             "phone_notification",
-        //             body: [
-        //                 "notificationId": "ancs-\(appID)-\(now)",
-        //                 "app": name.isEmpty ? appID : name,
-        //                 "title": "",
-        //                 "content": "",
-        //                 "priority": "0",
-        //                 "timestamp": now,
-        //                 "packageName": appID,
-        //             ]
-        //         )
-        //     }
-        // }
+        // carries app identity. The dedicated notification_app_seen event feeds
+        // the engine's seen-apps store, which backs the ANCS filter UI.
+        if cmd == NotificationCmd.ios.rawValue, let iosData = fields[4] as? Data {
+            var ios = ProtobufReader(iosData)
+            let iosFields = ios.parseFields()
+            let appID = (iosFields[1] as? Data).flatMap { String(data: $0, encoding: .utf8) }?
+                .trimmingCharacters(in: CharacterSet(charactersIn: "\0")) ?? ""
+            let name = (iosFields[2] as? Data).flatMap { String(data: $0, encoding: .utf8) }?
+                .trimmingCharacters(in: CharacterSet(charactersIn: "\0")) ?? ""
+            if !appID.isEmpty {
+                let now = Int64(Date().timeIntervalSince1970 * 1000)
+                Bridge.sendTypedMessage(
+                    "notification_app_seen",
+                    body: [
+                        "appId": appID,
+                        "displayName": name,
+                        "timestamp": now,
+                    ]
+                )
+                Bridge.sendTypedMessage(
+                    "phone_notification",
+                    body: [
+                        "notificationId": "ancs-\(appID)-\(now)",
+                        "app": name.isEmpty ? appID : name,
+                        "title": "",
+                        "content": "",
+                        "priority": "0",
+                        "timestamp": now,
+                        "packageName": appID,
+                    ]
+                )
+            }
+        }
     }
 
     /// EvenAI service (0x07). Logs the decoded EvenAIDataPackage so we can read the
@@ -6145,9 +6338,10 @@ final class G2: NSObject, SGCManager {
                 // )
 
                 if connStatus == 22 {
-                    Bridge.log("G2: Ring disconnected")
-                    DeviceStore.shared.apply("glasses", "controllerFullyBooted", false)
-                    DeviceStore.shared.apply("glasses", "controllerSearching", true)
+                    // The ring↔glasses link dropped. The phone↔ring link owns
+                    // controllerConnected/FullyBooted, so don't clear them here
+                    // (that would flap pairing state) — just re-request the link.
+                    Bridge.log("G2: Ring-glasses link dropped, re-requesting")
                     reconnectController()
                 }
 
@@ -6218,9 +6412,22 @@ final class G2: NSObject, SGCManager {
                 definitive: cmdValue == G2SettingCommandId.deviceReceiveRequest.rawValue
             )
             publishFirmwareVersion()
+            publishSceneCanvas()
         }
     }
 
+    /// Publish the CFW scene canvas into the glasses status once classification
+    /// lands. The engine's getEffectiveCapabilities keys its lifted element
+    /// caps off this (stock's 6-text/4-image container pools don't bound a
+    /// phone-rasterized CFW frame). Zeros on stock so a stale value can't
+    /// survive a CFW→stock swap.
+    private func publishSceneCanvas() {
+        guard cfwClassified else { return }
+        let active = supportsCfwSceneRendering
+        DeviceStore.shared.apply("glasses", "sceneCanvasWidth", active ? 576 : 0)
+        DeviceStore.shared.apply("glasses", "sceneCanvasHeight", active ? 288 : 0)
+    }
+
     private func updateCfwCapabilities(_ data: Data?, definitive: Bool) {
         // The sticky/definitive rules live in G2CfwClassification (unit-tested);
         // nil means the packet proved nothing and prior identity stands.
@@ -6533,14 +6740,14 @@ extension G2: CBCentralManagerDelegate {
                 if self.leftPeripheral == nil {
                     self.leftPeripheral = peripheral
                     peripheral.delegate = self
-                    central.connect(peripheral, options: nil)
+                    central.connect(peripheral, options: G2.peripheralConnectOptions)
                     // Bridge.log("G2: Connecting to LEFT: \(name)")
                 }
             } else if name.contains("_R_") {
                 if self.rightPeripheral == nil {
                     self.rightPeripheral = peripheral
                     peripheral.delegate = self
-                    central.connect(peripheral, options: nil)
+                    central.connect(peripheral, options: G2.peripheralConnectOptions)
                     // Bridge.log("G2: Connecting to RIGHT: \(name)")
                 }
             }
@@ -6553,6 +6760,26 @@ extension G2: CBCentralManagerDelegate {
         }
     }
 
+    nonisolated func centralManager(
+        _: CBCentralManager, didUpdateANCSAuthorizationFor peripheral: CBPeripheral
+    ) {
+        let authorized = peripheral.ancsAuthorized
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            let side = peripheral === self.leftPeripheral ? "LEFT" : "RIGHT"
+            Bridge.log("G2: ANCS authorization changed on \(side): \(authorized)")
+            self.publishAncsAuthorization()
+        }
+    }
+
+    /// Either lens being ANCS-authorized is enough — the firmware's ANCS client
+    /// runs on whichever arm holds the phone link.
+    private func publishAncsAuthorization() {
+        let authorized = (leftPeripheral?.ancsAuthorized ?? false)
+            || (rightPeripheral?.ancsAuthorized ?? false)
+        DeviceStore.shared.apply("glasses", "ancsAuthorized", authorized)
+    }
+
     nonisolated func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
@@ -6601,12 +6828,16 @@ extension G2: CBCentralManagerDelegate {
                     self.leftWriteChar = nil
                     self.leftNotifyChar = nil
                     self.leftAudioChar = nil
+                    self.leftFileWriteChar = nil
+                    self.leftFileNotifyChar = nil
                     self.leftAuthenticated = false
                 } else {
                     self.rightInitialized = false
                     self.rightWriteChar = nil
                     self.rightNotifyChar = nil
                     self.rightAudioChar = nil
+                    self.rightFileWriteChar = nil
+                    self.rightFileNotifyChar = nil
                     self.rightAuthenticated = false
                 }
                 Bridge.log("G2: \(side) rebooted during firmware flash; preserving the peer link")
@@ -6626,6 +6857,10 @@ extension G2: CBCentralManagerDelegate {
             self.rightNotifyChar = nil
             self.leftAudioChar = nil
             self.rightAudioChar = nil
+            self.leftFileWriteChar = nil
+            self.rightFileWriteChar = nil
+            self.leftFileNotifyChar = nil
+            self.rightFileNotifyChar = nil
             self.authStarted = false
             self.leftAuthenticated = false
             self.rightAuthenticated = false
@@ -6749,6 +6984,21 @@ extension G2: CBPeripheralDelegate {
                         self.rightAudioChar = char
                     }
                     peripheral.setNotifyValue(true, for: char)
+                } else if uuid == G2BLE.FILE_WRITE {
+                    Bridge.log("G2: Found FILE WRITE char on \(side)")
+                    if peripheral === self.leftPeripheral {
+                        self.leftFileWriteChar = char
+                    } else {
+                        self.rightFileWriteChar = char
+                    }
+                } else if uuid == G2BLE.FILE_NOTIFY {
+                    Bridge.log("G2: Found FILE NOTIFY char on \(side)")
+                    if peripheral === self.leftPeripheral {
+                        self.leftFileNotifyChar = char
+                    } else {
+                        self.rightFileNotifyChar = char
+                    }
+                    peripheral.setNotifyValue(true, for: char)
                 }
             }
 
@@ -6812,6 +7062,13 @@ extension G2: CBPeripheralDelegate {
             } else if characteristic.uuid == G2BLE.CHAR_NOTIFY {
                 // Protocol data
                 await self.handleNotifyData(data, from: peripheral)
+            } else if characteristic.uuid == G2BLE.FILE_NOTIFY {
+                // File-transfer responses (CACHE_HIT/MISS, transfer status) —
+                // observability for the notify-whitelist push.
+                let side = peripheral === self.leftPeripheral ? "L" : "R"
+                Bridge.log(
+                    "G2: FILE notify (\(side)): \(data.map { String(format: "%02X", $0) }.joined())"
+                )
             }
         }
     }