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

package/ios/Source/GlassesNotifications.swift

@@ -0,0 +1,181 @@
+import Foundation
+
+public enum GlassesNotificationError: Error, LocalizedError {
+    case unsupported
+    case notConnected
+    case invalidConfig(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .unsupported:
+            "The connected glasses have no notification surface"
+        case .notConnected:
+            "No glasses connected"
+        case let .invalidConfig(reason):
+            reason
+        }
+    }
+}
+
+/// Desired on-glass notification behaviour in glasses-neutral terms. Drivers map
+/// it onto their protocol and snap values their firmware cannot take.
+public struct GlassesNotificationConfig: Equatable, Sendable {
+    public struct AllowedApp: Equatable, Sendable {
+        public let id: String
+        public let name: String
+
+        public init(id: String, name: String) {
+            self.id = id
+            self.name = name
+        }
+    }
+
+    /// Popup duration the firmware is allowed to be handed, in seconds.
+    static let popupSecondsRange = 0 ... 60
+
+    public let enabled: Bool
+    public let popups: Bool
+    /// 0 lets the firmware choose.
+    public let popupSeconds: Int
+    public let holdDuringApps: Bool
+    /// Android package names or iOS bundle ids.
+    public let blockedApps: [String]
+    /// Known ids minus blocked, for firmware whose filter is an allowlist.
+    public let allowedApps: [AllowedApp]
+
+    public init(
+        enabled: Bool,
+        popups: Bool,
+        popupSeconds: Int,
+        holdDuringApps: Bool,
+        blockedApps: [String],
+        allowedApps: [AllowedApp]
+    ) {
+        self.enabled = enabled
+        self.popups = popups
+        self.popupSeconds = popupSeconds
+        self.holdDuringApps = holdDuringApps
+        self.blockedApps = blockedApps
+        self.allowedApps = allowedApps
+    }
+
+    /// Numbers arrive as NSNumber across the Expo bridge; `as? Int` would drop a Double.
+    public init(dictionary: [String: Any]) throws {
+        enabled = dictionary["enabled"] as? Bool ?? true
+        popups = dictionary["popups"] as? Bool ?? true
+        holdDuringApps = dictionary["holdDuringApps"] as? Bool ?? true
+
+        let seconds = (dictionary["popupSeconds"] as? NSNumber)?.intValue ?? 0
+        guard Self.popupSecondsRange.contains(seconds) else {
+            throw GlassesNotificationError.invalidConfig(
+                "popupSeconds \(seconds) outside \(Self.popupSecondsRange.lowerBound)…\(Self.popupSecondsRange.upperBound)"
+            )
+        }
+        popupSeconds = seconds
+
+        blockedApps = (dictionary["blockedApps"] as? [String] ?? []).filter { !$0.isEmpty }
+        allowedApps = (dictionary["allowedApps"] as? [[String: Any]] ?? []).compactMap { entry in
+            guard let id = entry["id"] as? String, !id.isEmpty else { return nil }
+            return AllowedApp(id: id, name: entry["name"] as? String ?? id)
+        }
+    }
+
+    public var dictionary: [String: Any] {
+        [
+            "enabled": enabled,
+            "popups": popups,
+            "popupSeconds": popupSeconds,
+            "holdDuringApps": holdDuringApps,
+            "blockedApps": blockedApps,
+            "allowedApps": allowedApps.map { ["id": $0.id, "name": $0.name] },
+        ]
+    }
+}
+
+public struct GlassesNotificationStatus: Sendable {
+    /// "phone_upload" | "ancs" | "none"
+    public let feed: String
+    /// "granted" | "denied" | "unknown" | "not_needed"
+    public let access: String
+    /// "idle" | "applying" | "applied" | "stale" | "error"
+    public let phase: String
+
+    public let supported: Bool
+    public let config: GlassesNotificationConfig?
+    public let error: String?
+
+    public init(
+        supported: Bool,
+        feed: String,
+        access: String,
+        phase: String,
+        config: GlassesNotificationConfig?,
+        error: String?
+    ) {
+        self.supported = supported
+        self.feed = feed
+        self.access = access
+        self.phase = phase
+        self.config = config
+        self.error = error
+    }
+
+    public static let unsupported = GlassesNotificationStatus(
+        supported: false,
+        feed: "none",
+        access: "not_needed",
+        phase: "idle",
+        config: nil,
+        error: nil
+    )
+
+    public var dictionary: [String: Any] {
+        [
+            "supported": supported,
+            "feed": feed,
+            "access": access,
+            "phase": phase,
+            "config": config?.dictionary ?? NSNull(),
+            "error": error ?? NSNull(),
+        ]
+    }
+}
+
+/// One phone notification handed to glasses that present content themselves.
+public struct PhoneNotificationUpload: Sendable {
+    public let notificationId: String
+    public let packageName: String
+    public let appName: String
+    public let title: String
+    public let subtitle: String
+    public let body: String
+    public let timestampMs: Int64
+
+    public init(
+        notificationId: String,
+        packageName: String,
+        appName: String,
+        title: String,
+        subtitle: String,
+        body: String,
+        timestampMs: Int64
+    ) {
+        self.notificationId = notificationId
+        self.packageName = packageName
+        self.appName = appName
+        self.title = title
+        self.subtitle = subtitle
+        self.body = body
+        self.timestampMs = timestampMs
+    }
+
+    public init(dictionary: [String: Any]) {
+        notificationId = dictionary["notificationId"] as? String ?? ""
+        packageName = dictionary["packageName"] as? String ?? ""
+        appName = dictionary["appName"] as? String ?? ""
+        title = dictionary["title"] as? String ?? ""
+        subtitle = dictionary["subtitle"] as? String ?? ""
+        body = dictionary["body"] as? String ?? ""
+        timestampMs = (dictionary["timestampMs"] as? NSNumber)?.int64Value ?? 0
+    }
+}

package/ios/Source/ObservableStore.swift

@@ -106,13 +106,25 @@ class ObservableStore {
         if let l = lhs as? Double, let r = rhs as? Double { return l == r }
         if let l = lhs as? [String], let r = rhs as? [String] { return l == r }
         if let l = lhs as? [[String: Any]], let r = rhs as? [[String: Any]] {
-            return toJson(l) == toJson(r)
+            return jsonEqual(l, r)
+        }
+        // Dict-valued settings — without this every apply re-fires the subscriber.
+        if let l = lhs as? [String: Any], let r = rhs as? [String: Any] {
+            return jsonEqual(l, r)
         }
         return false
     }
 
+    /// Unserializable on either side is "changed" — nil == nil must not read as equal.
+    private func jsonEqual(_ lhs: Any, _ rhs: Any) -> Bool {
+        guard let l = toJson(lhs), let r = toJson(rhs) else { return false }
+        return l == r
+    }
+
     private func toJson(_ value: Any) -> String? {
-        guard let data = try? JSONSerialization.data(withJSONObject: value) else { return nil }
+        guard JSONSerialization.isValidJSONObject(value),
+              let data = try? JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])
+        else { return nil }
         return String(data: data, encoding: .utf8)
     }
 }

package/ios/Source/Resources/G2Firmware/README.md

@@ -3,8 +3,33 @@
 The iOS target bundles the stock and Glassly CFW EVENOTA images stored in this
 directory. They were copied from the sibling `g2flash` checkout:
 
-- `g2_2.2.9.22.bin` -> `g2-stock-2.2.9.22.evenota.bin`
-- `g2_2.2.9.22_cfw.bin` -> `g2-glassly-cfw-2.2.9.22.evenota.bin`
+- `g2_2.3.0.24.bin` -> `g2-stock-2.3.0.24.evenota.bin`
+- `g2_2.3.0.24_cfw.bin` -> `g2-glassly-cfw-2.3.0.24.evenota.bin`
 
 Run `./build_cfw.sh` in `g2flash` before manually replacing the CFW image. The
 firmware binaries are committed so CI builds bundle them.
+
+The bundled CFW is **GLASSLYCFW/37**, built in `tetramo-labs/g2flash` at
+the commit named in its README, on stock G2 **2.3.0.24** (upstream
+jimrandomh/g2flash's new base with its audited stock ABI table). Every stock
+address was re-derived for 2.3.0.24; the fork keeps its own ANCS relay,
+phone-selectable fast BLE link and four-microphone relay, and gains upstream's
+ring touch-down and ring-report forwarding. Verified on hardware with the
+g2flash shapes, vector and Bad Apple suites and the fast-link toggle.
+Revision 38 adds the retained object cache (modes 37-41): objects and assets
+with 32-bit ids and versions survive a hidden view, so reopening the dashboard
+is one SHOW of references; the raw texture writes (mode 18) are gone. Verified
+on hardware with the g2flash vector and shapes suites (43/43).
+Field 100 is the bare revision string; clients gate on the number (the app
+requires 39).
+
+- Size: **4,661,963 bytes**
+- SHA-256: `4c7bf9a552df1a42f26b3378425c7c2121ca4058fed7283ec863c3f8d2cd13fe`
+
+Keep both platform copies and their `G2FirmwareCatalog` size/hash pins in sync.
+
+Revision 39 adds the BLE keyboard bridge (`patches/keyboard.c`): the right
+lens hosts one HID-over-GATT keyboard, driven by the phone over settings
+fields 130 (control) and 131 (events). Verified on hardware from the g2flash
+reference client (pairing, HOGP discovery and live key events); the phone
+path (G2KeyboardBridge) is not yet hardware-validated. The app requires 39.

package/ios/Source/controllers/R1.swift

@@ -1,6 +1,5 @@
 //
 //  R1.swift
-//  Glassly_Manager
 //
 //  Even Realities R1 Smart Ring controller
 //  Protocol reverse-engineered from BTSnoop captures and firmware analysis

package/ios/Source/internal/BluetoothAvailability.swift

@@ -1,15 +1,34 @@
 import CoreBluetooth
 import Foundation
 
+/// Phone-Bluetooth state watcher shared by every SDK command that needs the
+/// radio. Creating a `CBCentralManager` is what makes iOS show the Bluetooth
+/// permission alert, so the manager is created lazily on the first command
+/// that needs Bluetooth, never on app launch. `BluetoothSDK` is built when
+/// the Expo module is created, so an eager manager here prompts a fresh
+/// install before onboarding.
 final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
     static let shared = BluetoothAvailability()
 
     private var centralManager: CBCentralManager?
     private var state: CBManagerState = .unknown
+    /// CoreBluetooth reports state asynchronously after the manager exists.
+    /// Until the first report, `.unknown` means "not asked yet", not "broken".
+    private var hasReportedState = false
     private var listeners: [UUID: (CBManagerState) -> Void] = [:]
 
     override private init() {
         super.init()
+    }
+
+    /// True once a central manager exists (the permission alert has been
+    /// shown, or authorization was already decided).
+    var isActivated: Bool {
+        centralManager != nil
+    }
+
+    private func activate() {
+        guard centralManager == nil else { return }
         centralManager = CBCentralManager(
             delegate: self,
             queue: .main,
@@ -20,11 +39,15 @@ final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
 
     func centralManagerDidUpdateState(_ central: CBCentralManager) {
         state = central.state
+        hasReportedState = true
         for listener in Array(listeners.values) {
             listener(state)
         }
     }
 
+    /// Listeners registered before activation receive `.unknown` now and the
+    /// real state once a command activates the manager and CoreBluetooth
+    /// reports.
     @discardableResult
     func addStateListener(_ listener: @escaping (CBManagerState) -> Void) -> UUID {
         // `listeners` is unsynchronized; it is only safe because the central
@@ -42,6 +65,7 @@ final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
     }
 
     func requirePoweredOn(operation: String) throws {
+        activate()
         if let current = centralManager?.state {
             state = current
         }
@@ -63,6 +87,13 @@ final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
                 code: "bluetooth_unsupported",
                 message: "This phone does not support Bluetooth."
             )
+        case .unknown where !hasReportedState:
+            // First command after lazy activation: CoreBluetooth has not
+            // reported yet (the permission alert may be on screen). Let the
+            // command proceed; the per-device controller owns its own
+            // central manager and handles the radio state itself, and this
+            // gate enforces from the first report onward.
+            return
         case .resetting, .unknown:
             throw BluetoothSdkError(
                 code: "bluetooth_not_ready",