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

package/README.md

@@ -7,7 +7,7 @@ The package includes:
 - A React Native / Expo module API exposed as `BluetoothSdk`.
 - React hooks under `@glassly/bluetooth-sdk/react` for common scan,
   connection, status, and event lifecycles.
-- Native Android code published as `com.glassly:bluetooth-sdk`.
+- Native Android code published as `ai.glassly:bluetooth-sdk`.
 - Native iOS code available as the `BluetoothSDK` Swift package.
 - An Expo config plugin that wires the native dependencies into generated Android and iOS projects.
 
@@ -352,7 +352,7 @@ Android and iOS async APIs use `BluetoothSdkException` / `BluetoothSdkError` for
 React Native apps should use `MentraLiveOtaFlow` or `useMentraLiveOta` from
 `@glassly/engine/ota`. They provide the same tested Wi-Fi/hotspot,
 APK/MTK/BES, restart, retry, and verification flow as the Glassly App. See
-[Update Mentra Live](https://docs.glassly.com/bluetooth-sdk/software-update).
+[Update Mentra Live](https://docs.glassly.ai/bluetooth-sdk/software-update).
 
 The Bluetooth SDK exposes the lower-level commands and transport capabilities
 that Glassly Engine and native apps build on. They are not a replacement for the
@@ -409,7 +409,7 @@ OTA requires Mentra Live glasses firmware that supports the ASG OTA protocol and
 
 For release selection, bundle verification, analytics opt-out, internal server
 requirements, and disconnected validation, see the
-[air-gapped deployment guide](https://docs.glassly.com/bluetooth-sdk/air-gapped-deployment).
+[air-gapped deployment guide](https://docs.glassly.ai/bluetooth-sdk/air-gapped-deployment).
 
 Mentra Live also rejects `ota_start` before acknowledgement when its known battery level is below 5%, emitting a failed `ota_status` with `error_message: "battery_low"`. Unknown battery state remains fail-open, so apps should keep their own (typically stricter) user-facing battery policy.
 
@@ -458,6 +458,47 @@ await BluetoothSdk.stopStream()
 Use `rtmp://` or `rtmps://` for RTMP, `srt://` for SRT, and `http://` or `https://` for WHIP/WebRTC ingest. `startStream()` resolves with the correlated `stream_status` event once the glasses report `status: "streaming"`; `stopStream()` resolves when the glasses report `status: "stopped"` or confirms the stream was already stopped / not streaming. `stopStream()` returns a normalized stopped event for that already-stopped case. Stream starts reject if the glasses report an error before streaming; stream stops reject for real stop errors, send failure, another stop in flight, or timeout. Stream video input fields are `width`, `height`, `bitrate`, and `fps`. The SDK sends stream keep-alives automatically while streaming and reports keep-alive failures through `stream_status`. The camera light is always enabled while streaming.
 `stream_status` events may include `resolvedConfig`, which reports the effective transport, video, and audio settings after glasses defaults, clamps, and camera preflight. The resolved effective frame rate is reported as `resolvedConfig.video.fps`. While live, supported firmware emits periodic `streaming` events whose `stats` object contains `bitrate` (bits per second), `fps`, `droppedFrames`, `duration` (seconds), and `temperatureC` when the CPU sensor is available.
 
+## Glasses Notifications
+
+Some glasses present phone notifications themselves (popup + history) and take
+a glasses-neutral config. The SDK describes what the wearer wants; each driver
+maps it onto its own protocol and snaps values its firmware cannot take.
+
+```ts
+await BluetoothSdk.setGlassesNotificationConfig({
+  enabled: true,
+  popups: true, // false keeps history without popups
+  popupSeconds: 5, // 0 lets the firmware choose; drivers snap other values
+  holdDuringApps: true, // hold popups while navigation or a miniapp is on screen
+  blockedApps: [], // package names (Android) or bundle ids (iOS)
+  allowedApps: [], // known ids minus blocked, for firmware whose filter is an allowlist
+})
+const status = await BluetoothSdk.getGlassesNotificationStatus()
+const subscription = BluetoothSdk.addListener('glasses_notification_status', handleStatus)
+```
+
+`setGlassesNotificationConfig` rejects when no glasses are connected or the
+connected driver has no notification surface. The status reports `supported`,
+the `feed` (`ancs` when the glasses read the phone's notifications themselves,
+`phone_upload` when the phone hands them content, `none`), the wearer's
+`access` consent where one applies, and a `phase`. `applied` means the config
+was written to the link, not acknowledged by firmware; `stale` means a
+reconnect is needed. Drivers re-apply their last config after every reconnect.
+
+The G2 driver takes the config on both platforms. On iOS the glasses read the
+phone's notifications directly and the config also drives the on-glass
+allowlist file. On Android the phone uploads each notification as a small
+file over the glasses' file-transfer services; uploads are queued (eight
+pending, oldest dropped), serialized, and reported by id through
+`notification_upload_result` (`sent`, `failed`, `cancelled`, `dropped`) with no
+content attached. Disabling or disconnecting cancels queued uploads.
+
+`notification_upload_result` is typed and emitted, but it is not yet in the
+public listener allowlist, so `addListener("notification_upload_result", ...)`
+throws today. Until that is fixed, treat per-notification outcomes as
+diagnostic-only and drive UI from `getGlassesNotificationStatus()` and the
+`glasses_notification_status` event.
+
 ## Events
 
 React Native components should use `useBluetoothEvent()` for hardware events:
@@ -509,7 +550,7 @@ For normal app development, install the JavaScript package from npm. For SDK sou
 
 ```sh
 bun add --no-save /path/to/Glassly/mobile/modules/bluetooth-sdk
-GLASSLY_BLUETOOTH_SDK_PACKAGE_PATH=/path/to/Glassly/mobile/modules/bluetooth-sdk bunx expo run:ios
+BLUETOOTH_SDK_PACKAGE_PATH=/path/to/Glassly/mobile/modules/bluetooth-sdk bunx expo run:ios
 ```
 
 Use `bunx expo run:android` for Android. Keep local paths in your shell or CI environment, not in committed app config.
@@ -523,7 +564,7 @@ Glassly repo root:
 
 The `android/` folder in this package is source for the generated Expo Android
 project, not the local Gradle entrypoint. The check script prepares
-`mobile/android` and uses its Gradle wrapper with `-PglasslyPublicSdk=true`,
+`mobile/android` and uses its Gradle wrapper with `-PpublicSdk=true`,
 matching the CI release workflow's public SDK dependency mode.
 
 For bare native iOS apps, use the public SwiftPM repository:
@@ -551,7 +592,7 @@ Maintainers publishing the native Android artifacts to Maven Central should
 follow [RELEASING_ANDROID_MAVEN.md](./RELEASING_ANDROID_MAVEN.md).
 
 Public Maven publishing uses a public SDK mode that omits Glassly-only Android
-integrations from the artifact metadata while normal Glassly app builds keep
+integrations from the artifact metadata while normal Glassly App builds keep
 those integrations enabled.
 
 Use `android/gradle.properties.example` as the template for Sonatype Central and

package/android/build.gradle

@@ -7,8 +7,8 @@ apply plugin: 'signing'
 
 def packageJson = new JsonSlurper().parse(file("../package.json"))
 def mavenGroupId = 'ai.glassly'
-def mavenPublishVersion = (findProperty('glasslyMavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
-def publicMavenSdk = (findProperty('glasslyPublicSdk') ?: System.getenv('PUBLIC_SDK') ?: 'false').toString().toBoolean()
+def mavenPublishVersion = (findProperty('mavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
+def publicMavenSdk = (findProperty('publicSdk') ?: System.getenv('PUBLIC_SDK') ?: 'false').toString().toBoolean()
 
 // Download Sherpa-ONNX Android AAR from the upstream GitHub release and stage
 // it as a Maven artifact in a tiny on-disk repository under libs/maven/.
@@ -290,13 +290,13 @@ dependencies {
   // through the public SDK API. Public Maven artifacts compile against them
   // without publishing them as runtime transitives, so consumers only need
   // Maven Central/Google repositories for normal SDK use.
-  def optionalGlasslyIntegrationDependency = publicMavenSdk ? 'compileOnly' : 'implementation'
+  def optionalIntegrationDependency = publicMavenSdk ? 'compileOnly' : 'implementation'
 
   // Sherpa-ONNX for local transcription. Jitpack's v1.13.2 build failed
   // upstream, so we stage the prebuilt AAR into libs/maven/ (see top of file)
   // and consume it as a Maven coord — AGP rejects raw files() .aar deps in
   // library modules.
-  dependencies.add(optionalGlasslyIntegrationDependency, "${sherpaOnnxGroup}:${sherpaOnnxArtifact}:${sherpaOnnxVersion}@aar")
+  dependencies.add(optionalIntegrationDependency, "${sherpaOnnxGroup}:${sherpaOnnxArtifact}:${sherpaOnnxVersion}@aar")
 
   if (!publicMavenSdk) {
     // Silero VAD — vendored source under silero/, wired as :silero
@@ -318,8 +318,8 @@ dependencies {
     compileOnly 'com.squareup.picasso:picasso:2.8'
   }
 
-  implementation 'com.google.protobuf:protobuf-java:4.32.0'
-  implementation 'com.google.protobuf:protobuf-java-util:4.32.0'
+  implementation 'com.google.protobuf:protobuf-java:4.36.1'
+  implementation 'com.google.protobuf:protobuf-java-util:4.36.1'
 }
 
 // Pin onnxruntime-android to 1.27.0 — the version sherpa-onnx 1.13.4 was built
@@ -386,7 +386,7 @@ afterEvaluate {
     repositories {
       maven {
         name = 'sonatypeCentral'
-        def repositoryUrl = System.getenv('GLASSLY_MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
+        def repositoryUrl = System.getenv('MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
         url = uri(repositoryUrl)
         if (repositoryUrl.startsWith('http')) {
           credentials {

package/android/lc3Lib/build.gradle

@@ -8,7 +8,7 @@ plugins {
 
 def packageJson = new JsonSlurper().parse(file("../../package.json"))
 def mavenGroupId = 'ai.glassly'
-def mavenPublishVersion = (findProperty('glasslyMavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
+def mavenPublishVersion = (findProperty('mavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
 
 group = mavenGroupId
 version = mavenPublishVersion
@@ -181,7 +181,7 @@ afterEvaluate {
         repositories {
             maven {
                 name = 'sonatypeCentral'
-                def repositoryUrl = System.getenv('GLASSLY_MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
+                def repositoryUrl = System.getenv('MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
                 url = uri(repositoryUrl)
                 if (repositoryUrl.startsWith('http')) {
                     credentials {

package/android/src/main/assets/G2Firmware/README.md

@@ -3,9 +3,34 @@
 The Android library bundles the stock and Glassly CFW EVENOTA images stored in
 this directory. They are 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, and verified by size,
 SHA-256, per-component CRC32C, and the MRAM guard before flashing.
+
+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/android/src/main/java/com/glassly/bluetoothsdk/BluetoothSdk.kt

@@ -505,8 +505,19 @@ class BluetoothSdk private constructor(
         deviceManager.showNotificationsPanel()
     }
 
+    /** Apply on-glass notification behaviour. Throws when nothing is connected. */
+    fun setGlassesNotificationConfig(config: GlassesNotificationConfig) {
+        deviceManager.setGlassesNotificationConfig(config)
+    }
+
+    fun getGlassesNotificationStatus(): GlassesNotificationStatus =
+        deviceManager.glassesNotificationStatus()
+
     // ---------- Native navigation (glasses-rendered nav UI) ----------
 
+    suspend fun glassesSensorControl(sensor: String, operation: String, options: Map<String, Double>): Boolean =
+        deviceManager.glassesSensorControl(sensor, operation, options)
+
     fun navigationModeStart() {
         deviceManager.navigationModeStart()
     }
@@ -1226,6 +1237,33 @@ class BluetoothSdk private constructor(
         return deviceManager.startG2FirmwareFlash(target)
     }
 
+    // ---------- BLE keyboard bridge (G2 Glassly CFW revision 39+) ----------
+
+    suspend fun g2KeyboardScan(): List<Map<String, Any>> {
+        requireGlassesConnected("scan for a keyboard")
+        return deviceManager.g2KeyboardScan()
+    }
+
+    suspend fun g2KeyboardConnect(address: String, addressType: Int, name: String) {
+        requireGlassesConnected("connect a keyboard")
+        deviceManager.g2KeyboardConnect(address, addressType, name)
+    }
+
+    suspend fun g2KeyboardReconnect() {
+        requireGlassesConnected("reconnect the keyboard")
+        deviceManager.g2KeyboardReconnect()
+    }
+
+    suspend fun g2KeyboardDisconnect() = deviceManager.g2KeyboardDisconnect()
+
+    suspend fun g2KeyboardForget() = deviceManager.g2KeyboardForget()
+
+    suspend fun g2KeyboardPasskey(pin: Int) = deviceManager.g2KeyboardPasskey(pin)
+
+    suspend fun g2KeyboardCompare(accept: Boolean) = deviceManager.g2KeyboardCompare(accept)
+
+    suspend fun g2KeyboardStatus(): Map<String, Any> = deviceManager.g2KeyboardStatus()
+
     /** Select the HTTP(S) manifest used by subsequent OTA checks and installs. */
     fun setOtaVersionUrl(otaVersionUrl: String) {
         configuredOtaVersionUrl = OtaManifestChecker.normalizeHttpUrl(otaVersionUrl)

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

@@ -6,6 +6,7 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import com.glassly.bluetoothsdk.debug.BleTraceLogger
 import com.glassly.bluetoothsdk.speakerid.SpeakerIdEngine
+import com.glassly.bluetoothsdk.stt.STTTools
 import com.glassly.bluetoothsdk.utils.DeviceTypes
 import com.glassly.bluetoothsdk.utils.audio.PcmStreamManager
 import expo.modules.kotlin.exception.CodedException
@@ -331,10 +332,12 @@ class BluetoothSdkModule : Module() {
             "button_press",
             "touch_event",
             "accel_event",
+            "light_sensor",
             "compass_heading",
             "compass_calibration",
             "navigation_mode_change",
             "navigation_view_change",
+            "scene_frame_presented",
             "head_up",
             "voice_activity_detection_status",
             "speaking_status",
@@ -374,6 +377,8 @@ class BluetoothSdkModule : Module() {
             "speaker_enroll_result",
             "phone_notification",
             "phone_notification_dismissed",
+            "glasses_notification_status",
+            "notification_upload_result",
             "ws_text",
             "ws_bin",
             "mic_pcm",
@@ -394,6 +399,9 @@ class BluetoothSdkModule : Module() {
             "miniapp_selected",
             "captions_tester_incident",
             "extraction_progress",
+            "keyboard_key",
+            "keyboard_advert",
+            "keyboard_pairing",
         )
 
         OnCreate {
@@ -553,9 +561,27 @@ class BluetoothSdkModule : Module() {
 
         SdkAsyncFunction("showNativeNotificationPanel") { -> sdk?.showNotificationsPanel() }
 
+        SdkAsyncFunction("setGlassesNotificationConfig") { config: Map<String, Any> ->
+            sdk?.setGlassesNotificationConfig(GlassesNotificationConfig.fromMap(config))
+        }
+
+        SdkAsyncFunction("getGlassesNotificationStatus") { ->
+            (sdk?.getGlassesNotificationStatus() ?: GlassesNotificationStatus.unsupported()).toMap()
+        }
+
+        AsyncFunction("uploadPhoneNotification") { upload: Map<String, Any> ->
+            val parsed = PhoneNotificationUpload.fromMap(upload)
+            Bridge.log("MOD: uploadPhoneNotification package=${parsed.packageName}")
+            deviceManager?.uploadPhoneNotification(parsed)
+                ?: throw IllegalStateException("Glasses are not connected")
+        }
+
         // Native navigation mode (glasses-rendered nav UI — G2 today). The JS layer
         // feature-detects these by name (NativeNavigationService.isSupported), so the
         // export names must match iOS exactly.
+        SdkCoroutineFunction("glassesSensorControl") { sensor: String, operation: String, options: Map<String, Double> ->
+            sdk?.glassesSensorControl(sensor, operation, options) ?: false
+        }
         SdkAsyncFunction("navigationModeStart") { -> sdk?.navigationModeStart() }
         SdkAsyncFunction("navigationModeStop") { arrived: Boolean -> sdk?.navigationModeStop(arrived) }
         SdkAsyncFunction("navigationUpdateInfo") { params: Map<String, Any?> ->
@@ -570,14 +596,11 @@ class BluetoothSdkModule : Module() {
 
         AsyncFunction("ping") { deviceManager?.ping() }
 
-        AsyncFunction("dbg1") {
-            deviceManager?.dbg1()
-            deviceManager?.sgc?.dbg1()
-        }
-        AsyncFunction("dbg2") {
-            deviceManager?.dbg2()
-            deviceManager?.sgc?.dbg2()
-        }
+        // DeviceManager forwards to the active SGC; calling sgc here too fired each hook twice.
+        AsyncFunction("dbg1") { deviceManager?.dbg1() }
+        AsyncFunction("dbg2") { deviceManager?.dbg2() }
+        AsyncFunction("dbg3") { deviceManager?.dbg3() }
+        AsyncFunction("dbg4") { deviceManager?.dbg4() }
 
         // Stub on Android — iOS uses this for the jetsam stress test.
         Function("getMemoryMB") { -> 0.0 }
@@ -762,6 +785,19 @@ class BluetoothSdkModule : Module() {
             withContext(Dispatchers.IO) { requireSdk().startG2FirmwareFlash(target) }
         }
 
+        // MARK: - BLE keyboard bridge (G2 Glassly CFW revision 39+)
+
+        SdkCoroutineFunction("g2KeyboardScan") { -> requireSdk().g2KeyboardScan() }
+        SdkCoroutineFunction("g2KeyboardConnect") { address: String, addressType: Int, name: String ->
+            requireSdk().g2KeyboardConnect(address, addressType, name)
+        }
+        SdkCoroutineFunction("g2KeyboardReconnect") { -> requireSdk().g2KeyboardReconnect() }
+        SdkCoroutineFunction("g2KeyboardDisconnect") { -> requireSdk().g2KeyboardDisconnect() }
+        SdkCoroutineFunction("g2KeyboardForget") { -> requireSdk().g2KeyboardForget() }
+        SdkCoroutineFunction("g2KeyboardPasskey") { pin: Int -> requireSdk().g2KeyboardPasskey(pin) }
+        SdkCoroutineFunction("g2KeyboardCompare") { accept: Boolean -> requireSdk().g2KeyboardCompare(accept) }
+        SdkCoroutineFunction("g2KeyboardStatus") { -> requireSdk().g2KeyboardStatus() }
+
         // MARK: - Power Control Commands
 
         SdkAsyncFunction("sendShutdown") { -> sdk?.sendShutdown() }
@@ -840,7 +876,7 @@ class BluetoothSdkModule : Module() {
         // does a synchronous JNI model reload that would otherwise block every other
         // native call in the app until it completes.
         AsyncFunction("restartTranscriber") Coroutine { ->
-            withContext(Dispatchers.IO) { deviceManager?.restartTranscriber() }
+            withContext(Dispatchers.IO) { checkNotNull(deviceManager) { "Bluetooth SDK is not initialized" }.restartTranscriber() }
         }
 
         // MARK: - Speaker Identification
@@ -948,7 +984,7 @@ class BluetoothSdkModule : Module() {
                     appContext.reactContext
                             ?: appContext.currentActivity
                                     ?: throw IllegalStateException("No context available")
-            com.glassly.bluetoothsdk.stt.STTTools.setSttModelDetails(context, path, languageCode)
+            STTTools.setSttModelDetails(context, path, languageCode)
         }
 
         AsyncFunction("getSttModelPath") { ->
@@ -956,7 +992,7 @@ class BluetoothSdkModule : Module() {
                     appContext.reactContext
                             ?: appContext.currentActivity
                                     ?: throw IllegalStateException("No context available")
-            com.glassly.bluetoothsdk.stt.STTTools.getSttModelPath(context)
+            STTTools.getSttModelPath(context)
         }
 
         AsyncFunction("checkSttModelAvailable") { ->
@@ -964,11 +1000,11 @@ class BluetoothSdkModule : Module() {
                     appContext.reactContext
                             ?: appContext.currentActivity
                                     ?: throw IllegalStateException("No context available")
-            com.glassly.bluetoothsdk.stt.STTTools.checkSTTModelAvailable(context)
+            STTTools.checkSTTModelAvailable(context)
         }
 
         AsyncFunction("validateSttModel") { path: String ->
-            com.glassly.bluetoothsdk.stt.STTTools.validateSTTModel(path)
+            STTTools.validateSTTModel(path)
         }
 
         // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue: bz2/tar
@@ -976,7 +1012,7 @@ class BluetoothSdkModule : Module() {
         // shared queue it froze every other native call in the app until it finished.
         AsyncFunction("extractTarBz2") Coroutine { sourcePath: String, destinationPath: String ->
             withContext(Dispatchers.IO) {
-                com.glassly.bluetoothsdk.stt.STTTools.extractTarBz2(sourcePath, destinationPath)
+                STTTools.extractTarBz2(sourcePath, destinationPath)
             }
         }
 

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

@@ -172,6 +172,24 @@ public class Bridge private constructor() {
             sendTypedMessage("speaker_enroll_result", body as Map<String, Any>)
         }
 
+        /** display.render() frame outcome; seq 0 frames are native-originated and never reported. */
+        @JvmStatic
+        fun sendSceneFramePresented(seq: Int, appId: String, presented: Boolean, reason: String?) {
+            if (seq <= 0) return
+            val body = HashMap<String, Any>()
+            body["seq"] = seq
+            body["appId"] = appId
+            body["presented"] = presented
+            if (reason != null) body["reason"] = reason
+            sendTypedMessage("scene_frame_presented", body as Map<String, Any>)
+        }
+
+        /** The glasses finished every animation a tagged scene commit started (tag = frame seq & 0xFFFF). */
+        @JvmStatic
+        fun sendSceneSettled(tag: Int) {
+            sendTypedMessage("scene_settled", mapOf("tag" to tag))
+        }
+
         /** Send head position event */
         @JvmStatic
         fun sendHeadUp(isUp: Boolean) {