@mentra/bluetooth-sdk 3.1.0-dev.7 → 3.1.0-dev.71

package/src/changelogs.ts

@@ -0,0 +1,44 @@
+import type {ReleaseChangelog} from "./BluetoothSdk.types"
+import {GENERATED_RELEASE_CHANGELOGS} from "./generated/changelogCatalog"
+import {BLUETOOTH_SDK_RELEASE_METADATA} from "./generated/releaseMetadata"
+
+const BASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:[-+].*)?$/
+
+function baseVersion(version: string, label: string): string {
+  const match = BASE_VERSION_PATTERN.exec(version.trim())
+  if (!match) throw new Error(`${label} must be a semantic version such as 3.1.0, 3.1.0-dev.4, or 3.1.0-beta.2`)
+  return `${match[1]}.${match[2]}.${match[3]}`
+}
+
+function compareVersions(left: string, right: string): number {
+  const a = left.split(".").map(Number)
+  const b = right.split(".").map(Number)
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] - b[index]
+  }
+  return 0
+}
+
+/**
+ * Return authored release notes crossed between two product versions, newest first.
+ * The target release is always included, including transitions within one base train.
+ */
+export function getReleaseChangelogs(fromVersion?: string | null, toVersion?: string | null): ReleaseChangelog[] {
+  const fallbackTarget = BLUETOOTH_SDK_RELEASE_METADATA.familyBaseVersion ?? GENERATED_RELEASE_CHANGELOGS[0]?.version
+  if (!fallbackTarget && !toVersion) return []
+  const target = baseVersion(toVersion ?? fallbackTarget, "toVersion")
+  if (!GENERATED_RELEASE_CHANGELOGS.some(({version}) => version === target)) {
+    throw new Error(`No changelog is bundled for target version ${target}`)
+  }
+  if (!fromVersion) {
+    return GENERATED_RELEASE_CHANGELOGS.filter(({version}) => version === target).map((entry) => ({...entry}))
+  }
+
+  const source = baseVersion(fromVersion, "fromVersion")
+  const direction = compareVersions(target, source)
+  return GENERATED_RELEASE_CHANGELOGS.filter(({version}) => {
+    if (direction === 0) return version === target
+    if (direction > 0) return compareVersions(version, source) > 0 && compareVersions(version, target) <= 0
+    return compareVersions(version, source) < 0 && compareVersions(version, target) >= 0
+  }).map((entry) => ({...entry}))
+}

package/src/generated/changelogCatalog.ts

@@ -0,0 +1,9 @@
+/** Generated from /changelogs. Do not edit directly. */
+export const GENERATED_RELEASE_CHANGELOGS = Object.freeze(
+[
+  {
+    "version": "3.1.0",
+    "markdown": "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."
+  }
+] as const,
+)

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": "3.1.0",
-  "releaseIdentity": "3.1.0-dev.7",
-  "releaseSetId": "mentra-3.1.0-dev.7",
-  "sourceCommit": "872697a6395c31d30ec75d64f039eaa763dcbb51",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-v3.1.0-dev.7/mentra-live-ota-3.1.0-dev.7.json",
-  "otaManifestSha256": "8fbea7589345658dc5dffcb394229ffc5c52fbe75352acb8f6827d83290ce750"
+  "releaseIdentity": "3.1.0-dev.71",
+  "releaseSetId": "mentra-3.1.0-dev.71",
+  "sourceCommit": "314b41c83242c63409504b8ca733d74f022eb7d5",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.1.0/mentra-live-ota-3.1.0-dev.71.json",
+  "otaManifestSha256": "71904f40a2b648de0d626d05249be71baf8faffc27ad0bcb120d61001ed7d735"
 })

package/src/index.ts

@@ -3,8 +3,11 @@ import type {
   BluetoothSdkEventListener,
   BluetoothSdkEventName,
   BluetoothSdkPublicModule,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
   VideoRecordingDefaults,
 } from "./BluetoothSdk.types"
+import {getReleaseChangelogs} from "./changelogs"
 
 const PUBLIC_EVENT_NAMES = new Set<BluetoothSdkEventName>([
   "log",
@@ -46,6 +49,8 @@ const PUBLIC_EVENT_NAMES = new Set<BluetoothSdkEventName>([
   "mic_lc3",
   "mic_health",
   "stream_status",
+  "mtk_update_complete",
+  "glasses_session_changed",
   "ota_start_ack",
   "ota_status",
   "ar99_ota_status",
@@ -64,6 +69,10 @@ const startOtaUpdate: BluetoothSdkPublicModule["startOtaUpdate"] = (otaVersionUr
   return PrivateBluetoothSdkModule.startOtaUpdate(otaVersionUrl)
 }
 
+const queryOtaStatus: BluetoothSdkPublicModule["queryOtaStatus"] = () => {
+  return PrivateBluetoothSdkModule.sendOtaQueryStatus()
+}
+
 const bindPublicMethod = <K extends keyof BluetoothSdkPublicModule>(name: K): BluetoothSdkPublicModule[K] => {
   const method = (PrivateBluetoothSdkModule as unknown as Record<string, unknown>)[name]
   if (typeof method === "function") {
@@ -77,6 +86,12 @@ const bindPublicMethod = <K extends keyof BluetoothSdkPublicModule>(name: K): Bl
 
 export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   addListener,
+  getGlassesStatus: bindPublicMethod("getGlassesStatus"),
+  getBluetoothStatus: bindPublicMethod("getBluetoothStatus"),
+  subscribeGlassesStatus: (listener: (changed: Partial<PublicGlassesStatus>) => void) =>
+    PrivateBluetoothSdkModule.onGlassesStatus(listener),
+  subscribeBluetoothStatus: (listener: (changed: Partial<PublicBluetoothStatus>) => void) =>
+    PrivateBluetoothSdkModule.onBluetoothStatus(listener),
   getDefaultDevice: bindPublicMethod("getDefaultDevice"),
   setDefaultDevice: bindPublicMethod("setDefaultDevice"),
   clearDefaultDevice: bindPublicMethod("clearDefaultDevice"),
@@ -95,10 +110,12 @@ export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   setHeadUpAngle: bindPublicMethod("setHeadUpAngle"),
   setImuEnabled: bindPublicMethod("setImuEnabled"),
   setScreenDisabled: bindPublicMethod("setScreenDisabled"),
+  ping: bindPublicMethod("ping"),
   requestWifiScan: bindPublicMethod("requestWifiScan"),
   sendWifiCredentials: bindPublicMethod("sendWifiCredentials"),
   forgetWifiNetwork: bindPublicMethod("forgetWifiNetwork"),
   setHotspotState: bindPublicMethod("setHotspotState"),
+  setSystemTime: bindPublicMethod("setSystemTime"),
   setWifiAdbState: bindPublicMethod("setWifiAdbState"),
   setGalleryModeEnabled: bindPublicMethod("setGalleryModeEnabled"),
   setVoiceActivityDetectionEnabled: bindPublicMethod("setVoiceActivityDetectionEnabled"),
@@ -143,7 +160,9 @@ export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   setOtaVersionUrl: bindPublicMethod("setOtaVersionUrl"),
   getOtaVersionUrl: bindPublicMethod("getOtaVersionUrl"),
   checkForOtaUpdate: bindPublicMethod("checkForOtaUpdate"),
+  getReleaseChangelogs,
   startOtaUpdate,
+  queryOtaStatus,
   startAr99OtaFromFile: bindPublicMethod("startAr99OtaFromFile"),
   cancelAr99Ota: bindPublicMethod("cancelAr99Ota"),
   sendAr99FactoryReset: bindPublicMethod("sendAr99FactoryReset"),
@@ -212,6 +231,7 @@ export type {
   HotspotErrorEvent,
   HotspotStatus,
   HotspotStatusChangeEvent,
+  GlassesSessionChangedEvent,
   KeepAliveAckEvent,
   LocalTranscriptionEvent,
   LogEvent,
@@ -228,6 +248,8 @@ export type {
   OtaStatusEvent,
   OtaQueryResult,
   OtaUpdateInfo,
+  ReleaseChangelog,
+  MtkUpdateCompleteEvent,
   PairFailureEvent,
   PairingInfoEvent,
   EnteringPairingModeEvent,
@@ -238,6 +260,8 @@ export type {
   PhotoFpsRange,
   PhotoMeteredPreview,
   PhotoMode,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
   PhotoTransferMethod,
   PhotoResponseEvent,
   PhotoRequestedCaptureConfig,

package/src/ota-transport/index.ts

@@ -0,0 +1,116 @@
+// This public adapter is the package-owned boundary over its native implementation.
+// eslint-disable-next-line no-restricted-imports
+import MentraLocalNetwork from "../_private/MentraLocalNetworkModule"
+// eslint-disable-next-line no-restricted-imports
+import MentraOtaServer from "../ota-server"
+
+export type OtaTransportSubscription = {remove(): void}
+
+export type OtaLocalNetworkConnection = {
+  connected: boolean
+  ssid: string
+  localAddress?: string
+}
+
+export type OtaLocalNetworkLostEvent = {ssid: string}
+
+export type OtaLocalNetworkResponse = {
+  status: number
+  headers: Record<string, string>
+  bodyBase64: string
+}
+
+export type OtaLocalNetworkDownloadResult = {
+  statusCode: number
+  bytesWritten: number
+  headers: Record<string, string>
+}
+
+export type OtaLocalNetworkDownloadProgress = {
+  requestId: string
+  bytesWritten: number
+  contentLength: number
+  statusCode?: number
+  headers?: Record<string, string>
+}
+
+export type OtaArtifactDownloadProgress = {
+  destination: string
+  bytesWritten: number
+  contentLength: number
+}
+
+export type OtaServerResult = {
+  baseUrl: string
+  host: string
+  manifestUrl: string
+  port: number
+}
+
+/**
+ * Scoped networking for traffic that must stay on a Mentra Live hotspot while
+ * the phone's default route remains on cellular or another Wi-Fi network.
+ *
+ * The module is optional because iOS uses its system Wi-Fi join flow instead.
+ */
+export const otaLocalNetwork = Object.freeze({
+  isAvailable: (): boolean => MentraLocalNetwork != null,
+  connect: async (ssid: string, password: string): Promise<OtaLocalNetworkConnection> => {
+    if (!MentraLocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return MentraLocalNetwork.connect(ssid, password)
+  },
+  request: async (
+    requestId: string,
+    url: string,
+    method: string,
+    headers: Record<string, string>,
+    body: string | null,
+    timeoutMs: number,
+  ): Promise<OtaLocalNetworkResponse> => {
+    if (!MentraLocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return MentraLocalNetwork.request(requestId, url, method, headers, body, timeoutMs)
+  },
+  download: async (
+    requestId: string,
+    url: string,
+    destination: string,
+    headers: Record<string, string>,
+    connectionTimeoutMs: number,
+    readTimeoutMs: number,
+  ): Promise<OtaLocalNetworkDownloadResult> => {
+    if (!MentraLocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return MentraLocalNetwork.download(requestId, url, destination, headers, connectionTimeoutMs, readTimeoutMs)
+  },
+  cancel: async (requestId: string): Promise<void> => {
+    if (!MentraLocalNetwork) return
+    await MentraLocalNetwork.cancel(requestId)
+  },
+  disconnect: async (): Promise<void> => {
+    if (!MentraLocalNetwork) return
+    await MentraLocalNetwork.disconnect()
+  },
+  onDownloadProgress: (listener: (event: OtaLocalNetworkDownloadProgress) => void): OtaTransportSubscription => {
+    if (!MentraLocalNetwork) return {remove() {}}
+    return MentraLocalNetwork.addListener("downloadProgress", listener)
+  },
+  onNetworkLost: (listener: (event: OtaLocalNetworkLostEvent) => void): OtaTransportSubscription => {
+    if (!MentraLocalNetwork) return {remove() {}}
+    return MentraLocalNetwork.addListener("networkLost", listener)
+  },
+})
+
+/** Native HTTP server and artifact downloader used by the Engine OTA coordinator. */
+export const otaServer = Object.freeze({
+  start: (
+    manifestJson: string,
+    artifactPaths: Record<string, string>,
+    host?: string | null,
+  ): Promise<OtaServerResult> => MentraOtaServer.startOtaServer(manifestJson, artifactPaths, host),
+  stop: (): Promise<void> => MentraOtaServer.stopOtaServer(),
+  waitForWifiAddress: (gateway: string, timeoutMs: number): Promise<string> =>
+    MentraOtaServer.waitForWifiAddress(gateway, timeoutMs),
+  downloadArtifact: (source: string, destination: string): Promise<{statusCode: number; bytesWritten: number}> =>
+    MentraOtaServer.downloadArtifact(source, destination),
+  onArtifactDownloadProgress: (listener: (event: OtaArtifactDownloadProgress) => void): OtaTransportSubscription =>
+    MentraOtaServer.addListener("artifactDownloadProgress", listener),
+})