@glassly/bluetooth-sdk 0.1.0-dev.62 → 0.1.0-dev.90

package/ios/Source/sgcs/G2CfwRenderer.swift

@@ -156,10 +156,13 @@ actor G2CfwRenderer {
     }
 
     /// One firmware-drawn (mode 15) text line at absolute panel coordinates.
+    /// `boxWidth` is the source element's canvas-space box width — the erase
+    /// bounds floor, since the phone ellipsized the line against it.
     struct TextDraw: Equatable {
         let x: Int
         let y: Int
         let text: String
+        let boxWidth: Int
     }
 
     /// The result of one incremental encode: the wire payload (nil when the
@@ -210,9 +213,10 @@ actor G2CfwRenderer {
     }
 
     /// Caps for the delta planner. maxDirtyRects bounds fids the caller must
-    /// pre-allocate (one per rect, plus full frame, plus a move blank).
+    /// pre-allocate (one per rect, plus full frame, a move blank, and a
+    /// right-margin blank).
     static let maxDirtyRects = 6
-    static let requiredFidCount = maxDirtyRects + 2
+    static let requiredFidCount = maxDirtyRects + 3
     /// Cap on mode-14 runs per update (mode-8's count byte is the hard bound).
     static let maxGlyphRuns = 180
     /// Line pitch and default draw options of the glasses' builtin 20 px font
@@ -233,12 +237,17 @@ actor G2CfwRenderer {
     /// contained). `textDraws` are appended after the pixel segments so glyphs
     /// land on top of freshly pushed background. `blankBoxes` prepends a solid
     /// black frame at a previous window position (window move) in the same
-    /// atomic bundle. `omitBuiltinText` skips `font == "builtin"` text during
-    /// rasterization — the firmware draws those lines itself.
+    /// atomic bundle. `marginBlankBoxes` prepends a solid black frame OUTSIDE
+    /// the window — mode-15 draws at absolute panel coordinates without
+    /// clipping to the window, so stale glyph tails past the window's right
+    /// edge can only be erased by a frame aimed at the margin itself.
+    /// `omitBuiltinText` skips `font == "builtin"` text during rasterization —
+    /// the firmware draws those lines itself.
     func encodeUpdate(
         _ frame: SceneFrame, boxes: LensBoxes, previousRaster: Data?,
         forcedRects: [CanvasRect], fids: [UInt16], textDraws: [TextDraw],
-        allowRectCopy: Bool, blankBoxes: LensBoxes?, omitBuiltinText: Bool,
+        allowRectCopy: Bool, blankBoxes: LensBoxes?, marginBlankBoxes: LensBoxes? = nil,
+        omitBuiltinText: Bool,
         textureGlyphsEnabled: Bool = false, textureImagesEnabled: Bool = false,
         cacheGeneration: Int = 0
     ) -> SceneUpdate? {
@@ -282,6 +291,11 @@ actor G2CfwRenderer {
         if let blankBoxes, let blank = Self.solidStereoFrame(color: 0, boxes: blankBoxes, fid: takeFid()) {
             segments.append(blank)
         }
+        if let marginBlankBoxes,
+           let blank = Self.solidStereoFrame(color: 0, boxes: marginBlankBoxes, fid: takeFid())
+        {
+            segments.append(blank)
+        }
 
         let plan: DeltaPlan
         if let previousRaster, previousRaster.count == raster.count, blankBoxes == nil {
@@ -919,7 +933,7 @@ actor G2CfwRenderer {
             for (index, line) in text.split(separator: "\n", omittingEmptySubsequences: false).enumerated() {
                 let y = baseY + index * builtinLineHeight
                 guard y >= 0, y + builtinLineHeight <= frameHeight, !line.isEmpty else { continue }
-                draws.append(TextDraw(x: baseX, y: y, text: String(line)))
+                draws.append(TextDraw(x: baseX, y: y, text: String(line), boxWidth: Int(element.w)))
             }
         }
         return draws
@@ -927,7 +941,9 @@ actor G2CfwRenderer {
 
     /// Conservative canvas-space bounds of firmware-drawn text, used to force
     /// background re-pushes that erase glyphs the phone raster never
-    /// contained. Width is overestimated (the phone has no advance tables).
+    /// contained. The phone has no advance tables, so width is the char-count
+    /// estimate floored at the element's box width — wide glyphs overshoot
+    /// 13px/char, and an undershot erase leaves glyph tails on the panel.
     static func builtinTextBounds(
         _ draws: [TextDraw], boxes: LensBoxes, canvasWidth: Int, canvasHeight: Int
     ) -> [CanvasRect] {
@@ -935,7 +951,7 @@ actor G2CfwRenderer {
             let x = max(0, draw.x - Int(boxes.left.x) - 4)
             let y = max(0, draw.y - Int(boxes.left.y) - 2)
             guard x < canvasWidth, y < canvasHeight else { return nil }
-            let width = min(canvasWidth - x, draw.text.count * 13 + 30)
+            let width = min(canvasWidth - x, max(draw.text.count * 13 + 30, draw.boxWidth + 8))
             let height = min(canvasHeight - y, builtinLineHeight + 4)
             return CanvasRect(x: x, y: y, w: width, h: height)
         }

package/ios/Source/sgcs/G2FlashProtocol.swift

@@ -288,8 +288,8 @@ enum G2FlashProtocol {
     }
 
     static let goldenStock = GoldenVector(
-        sha256: "f4dfb0b49ad3de3c2daf17f8a27a157c3dc98411d6a0d3ab2cfd0918f41b9afa",
-        ps: 3_523_396, progEnd: 0x0079_4324, pass: true
+        sha256: "a03fbea9f68a9de6bc271daabb9f3a41c59053d1086622c76a4e990f829cc561",
+        ps: 3_697_284, progEnd: 0x007B_EA64, pass: true
     )
 
     /// Run the parse+guard on `img` and assert it reproduces the golden vector. Returns

package/ios/Source/sgcs/G2Flasher.swift

@@ -27,18 +27,18 @@ enum G2FirmwareCatalog {
         G2FirmwareArtifact(
             id: "stock",
             displayName: "Stock firmware",
-            version: "2.2.6.10",
-            fileName: "g2-stock-2.2.6.10.evenota.bin",
-            sha256: "f4dfb0b49ad3de3c2daf17f8a27a157c3dc98411d6a0d3ab2cfd0918f41b9afa",
-            size: 4_301_227
+            version: "2.2.9.22",
+            fileName: "g2-stock-2.2.9.22.evenota.bin",
+            sha256: "a03fbea9f68a9de6bc271daabb9f3a41c59053d1086622c76a4e990f829cc561",
+            size: 4_476_518
         ),
         G2FirmwareArtifact(
             id: "glassly-cfw",
             displayName: "Glassly CFW",
-            version: "2.2.6.10 CFW",
-            fileName: "g2-glassly-cfw-2.2.6.10.evenota.bin",
-            sha256: "82726bbe4d1d82f06a3d345ba3e5a4a39161077e5d26dcd7af24c4677df87fd1",
-            size: 4_336_071
+            version: "2.2.9.22 CFW",
+            fileName: "g2-glassly-cfw-2.2.9.22.evenota.bin",
+            sha256: "ceeede999529505ebc0a1369f57ab3c941273379a90b16669ccd39cc6bd99135",
+            size: 4_515_846
         ),
     ]
 

package/ios/Source/sgcs/SGCManager.swift

@@ -221,6 +221,13 @@ protocol SGCManager {
 
     func sendCalendarEvents(_ events: [[String: Any]])
 
+    // MARK: - Phone Notifications (on-glass ANCS display options + app filter)
+
+    /// Push NotificationControl from the DeviceStore `notification_ctrl` dict.
+    func sendNotificationCtrl()
+    /// Push the ANCS app allowlist from the DeviceStore `notification_filter` dict.
+    func sendNotificationFilter()
+
     // MARK: - Dashboard Display Settings
 
     func sendDashboardDisplaySettings()
@@ -469,6 +476,12 @@ extension SGCManager {
 
     func sendCalendarEvents(_: [[String: Any]]) {}
 
+    // MARK: - Phone Notifications (default no-op — only G2 filters ANCS on-glass)
+
+    func sendNotificationCtrl() {}
+
+    func sendNotificationFilter() {}
+
     // MARK: - Dashboard Display Settings (default no-op — only G2 supports this)
 
     func sendDashboardDisplaySettings() {}

package/ios/Source/utils/G2NotifyFile.swift

@@ -0,0 +1,116 @@
+//
+//  G2NotifyFile.swift
+//  BluetoothSDK
+//
+//  Pure helpers for the G2 notification whitelist file push
+//  (`user/notify_whitelist.json` over the 0xC4/0xC5 file-transfer services).
+//  Kept free of CoreBluetooth so the wire format is unit-testable.
+//
+
+import Foundation
+
+enum G2NotifyFile {
+    static let whitelistFilename = "user/notify_whitelist.json"
+
+    /// Firmware caps: 100-app list, 80-byte records (64-byte identifier
+    /// including NUL, 16-byte display name including NUL).
+    static let maxApps = 100
+    static let maxIdentifierBytes = 63
+    static let maxDisplayNameBytes = 15
+
+    /// CRC-32C (Castagnoli), init 0, non-reflected (MSB-first) — the variant the
+    /// G2 file-transfer FILE_CHECK header uses, NOT the common reflected crc32c.
+    private static let crc32cTable: [UInt32] = {
+        var table = [UInt32](repeating: 0, count: 256)
+        for i in 0 ..< 256 {
+            var crc = UInt32(i) << 24
+            for _ in 0 ..< 8 {
+                crc = (crc & 0x8000_0000) != 0 ? (crc << 1) ^ 0x1EDC_6F41 : crc << 1
+            }
+            table[i] = crc
+        }
+        return table
+    }()
+
+    static func crc32c(_ data: Data) -> UInt32 {
+        var crc: UInt32 = 0
+        for byte in data {
+            let idx = Int((crc >> 24) ^ UInt32(byte)) & 0xFF
+            crc = (crc << 8) ^ crc32cTable[idx]
+        }
+        return crc
+    }
+
+    /// 93-byte FILE_CHECK payload: mode, size, split CRC-32C, 80-byte
+    /// NUL-padded filename. The glasses reconstruct the checksum as
+    /// `(extra << 24) | (checksum >> 8)`.
+    static func fileCheckHeader(filename: String, content: Data) -> Data {
+        let crc = crc32c(content)
+        var header = Data()
+        // Mode 0x100: the even-g2-protocol docs' prose says 0x00010000, but the
+        // working example (`notification.py`) packs `<I` 0x100 — trust the code.
+        header.appendLittleEndianUInt32(0x100) // mode
+        header.appendLittleEndianUInt32(UInt32(content.count) &* 256) // size
+        header.appendLittleEndianUInt32(crc << 8) // checksum (low 24 bits, shifted)
+        header.append(UInt8(crc >> 24)) // extra (high CRC byte)
+        var name = Array(filename.utf8)
+        if name.count > 80 {
+            name = Array(name.prefix(80))
+        }
+        header.append(contentsOf: name)
+        header.append(contentsOf: [UInt8](repeating: 0, count: 80 - name.count))
+        return header
+    }
+
+    /// Whitelist JSON in the stock app's shape (AppNotificationInfo /
+    /// AppWhiteList / AppSimpleInfo from the decompiled Even app):
+    /// `{call_enable, msg_enable, calendar_enable, ios_mail_enable,
+    ///   app: {enable, list: [{id, name}]}}`
+    /// Entries with identifiers over 63 UTF-8 bytes are invalid to the firmware
+    /// and dropped; display names truncate to 15 UTF-8 bytes.
+    static func whitelistJson(filterEnabled: Bool, apps: [(id: String, name: String)]) -> Data {
+        var list: [[String: String]] = []
+        for app in apps {
+            guard !app.id.isEmpty, app.id.utf8.count <= maxIdentifierBytes else { continue }
+            let name = app.name.isEmpty ? app.id : app.name
+            list.append(["id": app.id, "name": truncateUtf8(name, maxBytes: maxDisplayNameBytes)])
+            if list.count >= maxApps {
+                break
+            }
+        }
+        let payload: [String: Any] = [
+            "call_enable": true,
+            "msg_enable": true,
+            "calendar_enable": true,
+            "ios_mail_enable": true,
+            "app": [
+                "enable": filterEnabled,
+                "list": list,
+            ] as [String: Any],
+        ]
+        // sortedKeys keeps the output deterministic (glasses cache by checksum).
+        return (try? JSONSerialization.data(withJSONObject: payload, options: [.sortedKeys])) ?? Data()
+    }
+
+    /// Truncate to a UTF-8 byte budget without splitting a code point.
+    static func truncateUtf8(_ value: String, maxBytes: Int) -> String {
+        if value.utf8.count <= maxBytes {
+            return value
+        }
+        var result = ""
+        for char in value {
+            if (result + String(char)).utf8.count > maxBytes {
+                break
+            }
+            result.append(char)
+        }
+        return result
+    }
+}
+
+private extension Data {
+    mutating func appendLittleEndianUInt32(_ value: UInt32) {
+        var v = value.littleEndian
+        Swift.withUnsafeBytes(of: &v) { append(contentsOf: $0) }
+    }
+}

package/ios/Tests/BluetoothSDKTests/G2CfwRendererTests.swift

@@ -361,8 +361,8 @@ final class G2CfwRendererTests: XCTestCase {
         )
         let draws = G2CfwRenderer.builtinTextDraws(frame([element]), boxes: b)
         XCTAssertEqual(draws, [
-            G2CfwRenderer.TextDraw(x: 32 + 10 + 2, y: 128 + 20 + 2, text: "one"),
-            G2CfwRenderer.TextDraw(x: 32 + 10 + 2, y: 128 + 20 + 2 + 27, text: "two"),
+            G2CfwRenderer.TextDraw(x: 32 + 10 + 2, y: 128 + 20 + 2, text: "one", boxWidth: 200),
+            G2CfwRenderer.TextDraw(x: 32 + 10 + 2, y: 128 + 20 + 2 + 27, text: "two", boxWidth: 200),
         ])
         let bounds = G2CfwRenderer.builtinTextBounds(draws, boxes: b, canvasWidth: 576, canvasHeight: 288)
         XCTAssertEqual(bounds.count, 2)

package/ios/Tests/BluetoothSDKTests/G2NotifyFileTests.swift

@@ -0,0 +1,91 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+/// Wire-format checks for the G2 notify-whitelist file push. Expected values
+/// cross-computed with the community reference implementation
+/// (even-g2-protocol examples/notif/notification.py).
+final class G2NotifyFileTests: XCTestCase {
+    func testCrc32cMatchesReferenceVectors() {
+        // Non-reflected (MSB-first) Castagnoli, init 0 — NOT the common
+        // reflected crc32c, whose check value for "123456789" is 0xE3069283.
+        XCTAssertEqual(G2NotifyFile.crc32c(Data("123456789".utf8)), 0xC052_A8C8)
+        XCTAssertEqual(G2NotifyFile.crc32c(Data()), 0)
+    }
+
+    func testFileCheckHeaderLayout() {
+        let content = Data(
+            #"{"app":{"enable":true,"list":[{"id":"com.apple.MobileSMS","name":"Messages"}]},"calendar_enable":true,"call_enable":true,"ios_mail_enable":true,"msg_enable":true}"#
+                .utf8
+        )
+        XCTAssertEqual(content.count, 162)
+        XCTAssertEqual(G2NotifyFile.crc32c(content), 0xE96D_1DA8)
+
+        let header = G2NotifyFile.fileCheckHeader(
+            filename: G2NotifyFile.whitelistFilename, content: content
+        )
+        XCTAssertEqual(header.count, 93)
+
+        func u32(_ offset: Int) -> UInt32 {
+            var value: UInt32 = 0
+            for i in (0 ..< 4).reversed() {
+                value = (value << 8) | UInt32(header[offset + i])
+            }
+            return value
+        }
+        XCTAssertEqual(u32(0), 0x100) // mode
+        XCTAssertEqual(u32(4), 41472) // size = len * 256
+        XCTAssertEqual(u32(8), 0x6D1D_A800) // checksum = crc << 8
+        XCTAssertEqual(header[12], 0xE9) // extra = crc >> 24
+
+        let nameBytes = header.subdata(in: 13 ..< 93)
+        let expectedName = Array(G2NotifyFile.whitelistFilename.utf8)
+        XCTAssertEqual(Array(nameBytes.prefix(expectedName.count)), expectedName)
+        XCTAssertTrue(nameBytes.dropFirst(expectedName.count).allSatisfy { $0 == 0 })
+    }
+
+    func testWhitelistJsonShape() throws {
+        let json = G2NotifyFile.whitelistJson(
+            filterEnabled: true,
+            apps: [
+                (id: "com.apple.MobileSMS", name: "Messages"),
+                (id: "", name: "dropped-empty-id"),
+                (id: String(repeating: "x", count: 64), name: "dropped-long-id"),
+                (id: "com.example.longname", name: "A name that is far too long to fit"),
+            ]
+        )
+        let root = try XCTUnwrap(
+            try JSONSerialization.jsonObject(with: json) as? [String: Any]
+        )
+        XCTAssertEqual(root["call_enable"] as? Bool, true)
+        XCTAssertEqual(root["msg_enable"] as? Bool, true)
+        XCTAssertEqual(root["calendar_enable"] as? Bool, true)
+        XCTAssertEqual(root["ios_mail_enable"] as? Bool, true)
+
+        let app = try XCTUnwrap(root["app"] as? [String: Any])
+        XCTAssertEqual(app["enable"] as? Bool, true)
+        let list = try XCTUnwrap(app["list"] as? [[String: String]])
+        XCTAssertEqual(list.count, 2)
+        XCTAssertEqual(list[0], ["id": "com.apple.MobileSMS", "name": "Messages"])
+        // Display names truncate to the firmware's 15-byte record budget.
+        XCTAssertEqual(list[1]["id"], "com.example.longname")
+        XCTAssertLessThanOrEqual(try XCTUnwrap(list[1]["name"]?.utf8.count), G2NotifyFile.maxDisplayNameBytes)
+    }
+
+    func testWhitelistJsonCapsAtFirmwareLimit() throws {
+        let apps = (0 ..< 150).map { (id: "com.example.app\($0)", name: "App \($0)") }
+        let json = G2NotifyFile.whitelistJson(filterEnabled: false, apps: apps)
+        let root = try XCTUnwrap(try JSONSerialization.jsonObject(with: json) as? [String: Any])
+        let app = try XCTUnwrap(root["app"] as? [String: Any])
+        XCTAssertEqual(app["enable"] as? Bool, false)
+        XCTAssertEqual((app["list"] as? [[String: String]])?.count, G2NotifyFile.maxApps)
+    }
+
+    func testTruncateUtf8RespectsCodePointBoundaries() {
+        XCTAssertEqual(G2NotifyFile.truncateUtf8("héllo wörld beyond", maxBytes: 15).utf8.count <= 15, true)
+        XCTAssertEqual(G2NotifyFile.truncateUtf8("short", maxBytes: 15), "short")
+        // 4-byte emoji must not be split mid-sequence.
+        let truncated = G2NotifyFile.truncateUtf8("aaaaaaaaaaaaaa😀", maxBytes: 15)
+        XCTAssertEqual(truncated, "aaaaaaaaaaaaaa")
+    }
+}

package/package.json

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

package/src/BluetoothSdk.types.ts

@@ -1015,6 +1015,7 @@ export type BluetoothSdkModuleEvents = {
   speaker_enroll_result: (event: SpeakerEnrollResultEvent) => void
   phone_notification: (event: PhoneNotificationEvent) => void
   phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void
+  notification_app_seen: (event: NotificationAppSeenEvent) => void
   wifi_status_change: (event: WifiStatusChangeEvent) => void
   wifi_scan_result: (event: WifiScanResultEvent) => void
   hotspot_status_change: (event: HotspotStatusChangeEvent) => void
@@ -1094,6 +1095,17 @@ export interface PhoneNotificationDismissedEvent {
   timestamp: number
 }
 
+/**
+ * iOS G2: the glasses' on-firmware ANCS client reported the source app of a
+ * notification (bundle id + display name — never the content). Feeds the
+ * seen-apps list backing the ANCS filter UI.
+ */
+export interface NotificationAppSeenEvent {
+  appId: string
+  displayName: string
+  timestamp: number
+}
+
 export type PublicGlassesStatus = Omit<
   GlassesStatus,
   "otaUpdateAvailable" | "otaProgress" | "otaInProgress" | "otaVersionUrl"
@@ -1209,7 +1221,6 @@ export interface BluetoothSdkPublicModule {
   displayText(text: string, x?: number, y?: number, size?: number): Promise<void>
   clearDisplay(): Promise<void>
   showDashboard(): Promise<void>
-  toggleHeadUp(): Promise<void>
   /**
    * Open the glasses' built-in notification panel (same effect as the user
    * saying "Hey Even, show notifications"). G2 only; a no-op elsewhere.
@@ -1477,6 +1488,12 @@ export interface GlassesStatus {
   controllerMacAddress: string
   controllerBatteryLevel: number
   controllerSignalStrength: number
+  /**
+   * iOS: a connected lens is authorized to read the phone's ANCS notification
+   * stream (the "Share System Notifications" Bluetooth consent). Always false
+   * on Android and for models that don't consume ANCS on-firmware.
+   */
+  ancsAuthorized?: boolean
 }
 
 export interface CoreDashboardMenuItem {
@@ -1497,6 +1514,23 @@ export interface CoreSettings {
   calendar_events: CalendarEvent[]
 }
 
+/** G2 on-glass notification display behavior (NotificationControl protobuf). */
+export interface G2NotificationCtrlSetting {
+  enabled: boolean
+  auto_display: boolean
+  /** On-screen popup duration in seconds: 0 (firmware default), 5, 7, or 10. */
+  disp_time: number
+  avoid_disturb: boolean
+}
+
+/** G2 on-glass ANCS app filter (user/notify_whitelist.json push). */
+export interface G2NotificationFilterSetting {
+  /** false = whitelisting off on-glass (fail-open, every app shows). */
+  enabled: boolean
+  /** Allowlist entries; identifiers are iOS bundle ids. */
+  apps: Array<{id: string; name: string}>
+}
+
 export interface Device {
   /**
    * Stable app-facing key for this scan result, within the limits of the
@@ -1595,6 +1629,8 @@ export type BluetoothSettingsUpdate = Partial<{
   dashboard_depth: number
   menu_apps: DashboardMenuItem[] | CoreDashboardMenuItem[] | Array<Record<string, unknown>> | null
   calendar_events: CalendarEvent[]
+  notification_ctrl: G2NotificationCtrlSetting
+  notification_filter: G2NotificationFilterSetting
   metric_system: boolean
   twelve_hour_time: boolean
   gallery_mode: boolean

package/src/_private/BluetoothSdkModule.ts

@@ -108,7 +108,6 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   forget(): Promise<void>
   forgetController(): Promise<void>
   showDashboard(): Promise<void>
-  toggleHeadUp(): Promise<void>
   setBrightness(level: number, autoMode?: boolean | null): Promise<void>
   setAutoBrightness(enabled: boolean): Promise<void>
   setDashboardPosition(height: number, depth: number): Promise<void>

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.62",
-  "releaseSetId": "glassly-0.1.0-dev.62",
-  "sourceCommit": "69eee438b882fca1c9b0ad466d71fc2c24053662",
+  "releaseIdentity": "0.1.0-dev.90",
+  "releaseSetId": "glassly-0.1.0-dev.90",
+  "sourceCommit": "1140c7490313353cb1d8da0782bf74c87d9119eb",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/index.ts

@@ -107,7 +107,6 @@ export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   displayText: bindPublicMethod("displayText"),
   clearDisplay: bindPublicMethod("clearDisplay"),
   showDashboard: bindPublicMethod("showDashboard"),
-  toggleHeadUp: bindPublicMethod("toggleHeadUp"),
   showNativeNotificationPanel: bindPublicMethod("showNativeNotificationPanel"),
   setDashboardPosition: bindPublicMethod("setDashboardPosition"),
   setHeadUpAngle: bindPublicMethod("setHeadUpAngle"),