@mentra/bluetooth-sdk 0.1.21-beta.0 → 0.1.21-beta.2

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/ar99/ota/OtaProtocol.java

@@ -0,0 +1,92 @@
+package com.mentra.bluetoothsdk.sgcs.ar99.ota;
+
+import java.io.ByteArrayOutputStream;
+
+public final class OtaProtocol {
+  private OtaProtocol() {}
+
+  public static byte[] buildFrame(byte cmd, byte paramType, byte[] payload) {
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    out.write(OtaCommandConstants.OTA.SVC_ID & 0xFF);
+    out.write(cmd & 0xFF);
+    out.write(paramType & 0xFF);
+    int len = payload != null ? payload.length : 0;
+    out.write(len & 0xFF);
+    out.write((len >> 8) & 0xFF);
+    if (payload != null && payload.length > 0) {
+      try {
+        out.write(payload);
+      } catch (Exception ignored) {
+      }
+    }
+    return out.toByteArray();
+  }
+
+  public static byte[] buildRequestUpgrade(int packageSize, int blockSize, long crc32) {
+    // Wire layout matches the vendor bring-up frame: type marker, then TLV
+    // 0x0A/len4 = package size (LE). CRC is validated per-block in SEND_IMAGE_DATA;
+    // blockSize is negotiated separately in CONNECT_NEGOTIATION.
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(0x09);
+    payload.write(0x01);
+    payload.write(0x00);
+    payload.write(0x01);
+    payload.write(0x0A);
+    payload.write(0x04);
+    payload.write(packageSize & 0xFF);
+    payload.write((packageSize >> 8) & 0xFF);
+    payload.write((packageSize >> 16) & 0xFF);
+    payload.write((packageSize >> 24) & 0xFF);
+    payload.write(0x00);
+    return buildFrame(OtaCommandConstants.OTA.REQUEST_UPGRADE, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static byte[] buildConnectNegotiation(int blockSize) {
+    return buildFrame(OtaCommandConstants.OTA.CONNECT_NEGOTIATION, (byte) 0x80, null);
+  }
+
+  public static byte[] buildNegotiationResult() {
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(0x01);
+    payload.write(0x01);
+    payload.write(0x00);
+    payload.write(0x01);
+    return buildFrame(OtaCommandConstants.OTA.NEGOTIATION_RESULT, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static byte[] buildSendImageData(int psn, byte[] data) {
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(psn & 0xFF);
+    long crc32 = OtaCrc32Util.calculate(data);
+    payload.write((byte) (crc32 & 0xFF));
+    payload.write((byte) ((crc32 >> 8) & 0xFF));
+    payload.write((byte) ((crc32 >> 16) & 0xFF));
+    payload.write((byte) ((crc32 >> 24) & 0xFF));
+    if (data != null && data.length > 0) {
+      try {
+        payload.write(data);
+      } catch (Exception ignored) {
+      }
+    }
+    return buildFrame(OtaCommandConstants.OTA.SEND_IMAGE_DATA, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static FrameHeader parseFrameHeader(byte[] frame) {
+    if (frame == null || frame.length < 5) return null;
+    FrameHeader header = new FrameHeader();
+    header.svcId = frame[0];
+    header.cmd = frame[1];
+    header.paramType = frame[2];
+    header.paramLen = OtaByteUtils.readShortLE(frame, 3) & 0xFFFF;
+    header.payloadOffset = 5;
+    return header;
+  }
+
+  public static class FrameHeader {
+    public byte svcId;
+    public byte cmd;
+    public byte paramType;
+    public int paramLen;
+    public int payloadOffset;
+  }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -168,12 +168,45 @@ data class StreamResolvedConfig @JvmOverloads constructor(
     }
 }
 
+/** Live encoder and device telemetry reported by the glasses while streaming. */
+data class StreamLiveStats @JvmOverloads constructor(
+    val bitrate: Long? = null,
+    val fps: Double? = null,
+    val droppedFrames: Long? = null,
+    val duration: Long? = null,
+    val temperatureC: Double? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            bitrate?.let { put("bitrate", it) }
+            fps?.let { put("fps", it) }
+            droppedFrames?.let { put("droppedFrames", it) }
+            duration?.let { put("duration", it) }
+            temperatureC?.let { put("temperatureC", it) }
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamLiveStats? {
+            values ?: return null
+            return StreamLiveStats(
+                bitrate = longValue(values, "bitrate"),
+                fps = doubleValue(values, "fps"),
+                droppedFrames = longValue(values, "droppedFrames"),
+                duration = longValue(values, "duration"),
+                temperatureC = doubleValue(values, "temperatureC"),
+            )
+        }
+    }
+}
+
 data class StreamRequest @JvmOverloads constructor(
     val streamUrl: String,
     val streamId: String = "",
     val sound: Boolean = true,
     val video: StreamVideoConfig? = null,
     val audio: StreamAudioConfig? = null,
+    val authToken: String? = null,
 ) {
     fun toMap(): Map<String, Any> =
         buildMap {
@@ -183,6 +216,7 @@ data class StreamRequest @JvmOverloads constructor(
             put("sound", sound)
             video?.toMap()?.takeIf { it.isNotEmpty() }?.let { put("video", it) }
             audio?.toMap()?.takeIf { it.isNotEmpty() }?.let { put("audio", it) }
+            authToken?.takeIf { it.isNotEmpty() }?.let { put("authToken", it) }
         }
 
     companion object {
@@ -196,6 +230,7 @@ data class StreamRequest @JvmOverloads constructor(
                 sound = values["sound"] as? Boolean ?: true,
                 video = StreamVideoConfig.fromMap(stringMapValue(values["video"])),
                 audio = StreamAudioConfig.fromMap(stringMapValue(values["audio"])),
+                authToken = values["authToken"] as? String ?: values["auth_token"] as? String,
             )
     }
 }
@@ -435,6 +470,7 @@ sealed interface StreamStatus {
 
 data class StreamStatusEvent(
     val status: StreamStatus,
+    val stats: StreamLiveStats? = null,
 ) {
     // True when the glasses will retry the failed publisher themselves
     // (emitting side lands in PR #3488); absent on older firmware and on
@@ -443,7 +479,10 @@ data class StreamStatusEvent(
     var willRetry: Boolean? = null
         private set
 
-    constructor(values: Map<String, Any>) : this(StreamStatus.fromMap(values)) {
+    constructor(values: Map<String, Any>) : this(
+        status = StreamStatus.fromMap(values),
+        stats = StreamLiveStats.fromMap(stringMapValue(values["stats"])),
+    ) {
         willRetry = boolValue(values, "willRetry")
     }
 
@@ -453,6 +492,7 @@ data class StreamStatusEvent(
     val values: Map<String, Any>
         get() = buildMap {
             putAll(status.toEventMap())
+            stats?.let { put("stats", it.toMap()) }
             willRetry?.let { put("willRetry", it) }
         }
 }

package/android/src/main/java/com/mentra/bluetoothsdk/types/DeviceModels.kt

@@ -23,6 +23,7 @@ enum class DeviceModel(val deviceType: String) {
     Z100(DeviceTypes.Z100),
     FRAME(DeviceTypes.FRAME),
     NIMO(DeviceTypes.NIMO),
+    AR99(DeviceTypes.AR99),
     SIMULATED(DeviceTypes.SIMULATED),
     R1(ControllerTypes.R1);
 
@@ -38,6 +39,7 @@ data class Device(
     val name: String,
     /** Android Bluetooth address when available. */
     val address: String? = null,
+    val projectName: String? = null,
     val rssi: Int? = null,
     /** Stable app-facing scan-result key. Do not parse; use typed fields instead. */
     val id: String = address?.takeIf { it.isNotBlank() } ?: "${model.deviceType}:$name",
@@ -50,6 +52,9 @@ data class Device(
             address?.takeIf { it.isNotBlank() }?.let {
                 put("address", it)
             }
+            projectName?.takeIf { it.isNotBlank() }?.let {
+                put("projectName", it)
+            }
             rssi?.let { put("rssi", it) }
         }
 
@@ -58,12 +63,14 @@ data class Device(
             val model = stringValue(values, "model") ?: return null
             val name = stringValue(values, "name") ?: return null
             val address = stringValue(values, "address")?.takeIf { it.isNotBlank() }
+            val projectName = stringValue(values, "projectName")?.takeIf { it.isNotBlank() }
             val rssi = numberValue(values, "rssi")
             val id = stringValue(values, "id")?.takeIf { it.isNotBlank() } ?: address ?: "${model}:$name"
             return Device(
                 model = DeviceModel.fromDeviceType(model),
                 name = name,
                 address = address,
+                projectName = projectName,
                 rssi = rssi,
                 id = id,
             )

package/android/src/main/java/com/mentra/bluetoothsdk/utils/BleJsonCompact.java

@@ -66,6 +66,14 @@ public final class BleJsonCompact {
         putKey("transferMethod", "tm");
         putKey("manual", "m");
         putKey("reconnecting", "rc");
+        putKey("stats", "st");
+        putKey("width", "w");
+        putKey("height", "h");
+        putKey("bitrate", "br");
+        putKey("fps", "f");
+        putKey("droppedFrames", "df");
+        putKey("duration", "du");
+        putKey("temperatureC", "tc");
 
         putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "accepted", 0);
         putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "queued", 1);

package/android/src/main/java/com/mentra/bluetoothsdk/utils/Constants.kt

@@ -10,7 +10,8 @@ object DeviceTypes {
     const val FRAME = "Brilliant Frame"
     const val G2 = "Even Realities G2"
     const val NIMO = "NIMO"
-    val ALL = arrayOf(SIMULATED, G1, G2, MACH1, LIVE, Z100, FRAME, NEX, NIMO)
+    const val AR99 = "AR99"
+    val ALL = arrayOf(SIMULATED, G1, G2, MACH1, LIVE, Z100, FRAME, NEX, NIMO, AR99)
 }
 
 object ControllerTypes {

package/android/src/main/java/com/mentra/bluetoothsdk/utils/PhoneAudioMonitor.kt

@@ -26,6 +26,14 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
         @Volatile
         private var instance: PhoneAudioMonitor? = null
 
+        internal fun shouldKeepOwnAppAudioSignal(
+            signalledPlaying: Boolean,
+            systemAudioPlaying: Boolean,
+            nowMs: Long,
+            holdoffUntilMs: Long,
+        ): Boolean =
+            signalledPlaying && (systemAudioPlaying || nowMs < holdoffUntilMs)
+
         @JvmStatic
         fun getInstance(context: Context): PhoneAudioMonitor {
             return instance ?: synchronized(this) {
@@ -48,6 +56,10 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
     private var listener: Listener? = null
     private var isMonitoring = false
     private var lastKnownState = false
+    // Set explicitly by AudioPlaybackService. Unlike isPlaying(), this is
+    // limited to Mentra's own playback and is safe for mic-watchdog gating.
+    @Volatile
+    private var ownAppAudioPlaying = false
 
     // Rate limiting: max 1 state change notification per 500ms
     // If state changes rapidly (true/false/true), we wait and send the final state
@@ -78,6 +90,37 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
         return audioManager.isMusicActive
     }
 
+    /**
+     * Return the explicit React Native playback hint, reconciling it with
+     * Android's actual media state.
+     *
+     * Expo can miss a completion callback while its Activity is backgrounded,
+     * leaving the explicit hint stuck at PLAYING. The hint only protects the
+     * short A2DP codec transition; after that hold-off, Android's
+     * isMusicActive is authoritative. Clearing a stale hint lets the glasses
+     * mic watchdog recover instead of suppressing recovery forever.
+     */
+    @Synchronized
+    fun isOwnAppAudioPlaying(): Boolean {
+        val systemAudioPlaying = isPlaying()
+        if (
+            shouldKeepOwnAppAudioSignal(
+                ownAppAudioPlaying,
+                systemAudioPlaying,
+                System.currentTimeMillis(),
+                audioStartHoldoffUntil,
+            )
+        ) {
+            return true
+        }
+
+        if (ownAppAudioPlaying) {
+            ownAppAudioPlaying = false
+            Bridge.log("$TAG: Cleared stale own-app audio flag (system audio is inactive)")
+        }
+        return false
+    }
+
     /**
      * Notify the monitor that our own app started/stopped playing audio
      * Called from RN AudioPlaybackService via Bridge
@@ -87,7 +130,9 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
      * there's a brief gap where the system reports 0 active configs (codec is switching).
      * The hold-off prevents us from reporting STOPPED during this transition.
      */
+    @Synchronized
     fun setOwnAppAudioPlaying(playing: Boolean) {
+        ownAppAudioPlaying = playing
         Bridge.log("$TAG: Own app audio -> ${if (playing) "PLAYING" else "STOPPED"}")
 
         if (playing) {