@mentra/bluetooth-sdk 0.1.21-beta.3 → 3.1.0-dev.10

package/build/ota-server/index.js

@@ -0,0 +1,3 @@
+export { default } from "./MentraOtaServerModule";
+export * from "./MentraOtaServer.types";
+//# sourceMappingURL=index.js.map

package/build/ota-server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ota-server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,yBAAyB,CAAA;AAC/C,cAAc,yBAAyB,CAAA","sourcesContent":["export {default} from \"./MentraOtaServerModule\"\nexport * from \"./MentraOtaServer.types\"\n"]}

package/expo-module.config.json

@@ -1,13 +1,14 @@
 {
   "platforms": ["apple", "android"],
   "apple": {
-    "modules": ["BluetoothSdkModule", "MentraPhotoReceiverModule"]
+    "modules": ["BluetoothSdkModule", "MentraPhotoReceiverModule", "MentraOtaServerModule"]
   },
   "android": {
     "modules": [
       "com.mentra.bluetoothsdk.BluetoothSdkModule",
       "com.mentra.bluetoothsdk.MentraLocalNetworkModule",
-      "com.mentra.bluetoothsdk.photoreceiver.MentraPhotoReceiverModule"
+      "com.mentra.bluetoothsdk.photoreceiver.MentraPhotoReceiverModule",
+      "com.mentra.bluetoothsdk.otaserver.MentraOtaServerModule"
     ]
   }
 }

package/ios/BackgroundOtaArtifactDownloader.swift

@@ -0,0 +1,125 @@
+import Foundation
+
+/// Background-capable, native artifact staging for hotspot OTA.
+final class BackgroundOtaArtifactDownloader: NSObject, URLSessionDownloadDelegate, URLSessionTaskDelegate {
+  typealias ProgressHandler = (_ destination: String, _ written: Int64, _ total: Int64) -> Void
+
+  private struct Pending {
+    let continuation: CheckedContinuation<[String: Any], Error>
+  }
+
+  private let lock = NSLock()
+  private let onProgress: ProgressHandler
+  private var pending: [Int: Pending] = [:]
+  private lazy var session: URLSession = {
+    let configuration = URLSessionConfiguration.background(
+      withIdentifier: "com.mentra.bluetooth-sdk.hotspot-ota-artifacts"
+    )
+    configuration.sessionSendsLaunchEvents = true
+    configuration.isDiscretionary = false
+    configuration.waitsForConnectivity = true
+    return URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+  }()
+
+  init(onProgress: @escaping ProgressHandler) {
+    self.onProgress = onProgress
+    super.init()
+  }
+
+  func download(from source: String, to destination: String) async throws -> [String: Any] {
+    guard let sourceUrl = URL(string: source),
+          sourceUrl.scheme == "https" || sourceUrl.scheme == "http"
+    else {
+      throw OtaServerError("Invalid artifact URL")
+    }
+
+    if FileManager.default.fileExists(atPath: destination) {
+      let size = fileSize(atPath: destination)
+      return ["statusCode": 200, "bytesWritten": size]
+    }
+
+    try FileManager.default.createDirectory(
+      at: URL(fileURLWithPath: destination).deletingLastPathComponent(),
+      withIntermediateDirectories: true
+    )
+
+    return try await withCheckedThrowingContinuation { continuation in
+      let task = session.downloadTask(with: sourceUrl)
+      task.taskDescription = destination
+      lock.lock()
+      pending[task.taskIdentifier] = Pending(continuation: continuation)
+      lock.unlock()
+      task.resume()
+    }
+  }
+
+  func urlSession(
+    _: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didWriteData _: Int64,
+    totalBytesWritten: Int64,
+    totalBytesExpectedToWrite: Int64
+  ) {
+    guard let destination = downloadTask.taskDescription else { return }
+    onProgress(destination, totalBytesWritten, totalBytesExpectedToWrite)
+  }
+
+  func urlSession(
+    _: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didFinishDownloadingTo location: URL
+  ) {
+    guard let destination = downloadTask.taskDescription else { return }
+    guard let response = downloadTask.response as? HTTPURLResponse,
+          (200 ... 299).contains(response.statusCode)
+    else {
+      let status = (downloadTask.response as? HTTPURLResponse)?.statusCode ?? 0
+      reject(
+        taskId: downloadTask.taskIdentifier,
+        error: OtaServerError("Artifact download failed with HTTP \(status)")
+      )
+      return
+    }
+    let destinationUrl = URL(fileURLWithPath: destination)
+    do {
+      try? FileManager.default.removeItem(at: destinationUrl)
+      try FileManager.default.moveItem(at: location, to: destinationUrl)
+      let size = fileSize(atPath: destination)
+      resolve(
+        taskId: downloadTask.taskIdentifier,
+        result: ["statusCode": response.statusCode, "bytesWritten": size]
+      )
+    } catch {
+      reject(taskId: downloadTask.taskIdentifier, error: error)
+    }
+  }
+
+  func urlSession(_: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    if let error {
+      reject(taskId: task.taskIdentifier, error: error)
+    }
+  }
+
+  private func resolve(taskId: Int, result: [String: Any]) {
+    lock.lock()
+    let item = pending.removeValue(forKey: taskId)
+    lock.unlock()
+    item?.continuation.resume(returning: result)
+  }
+
+  private func reject(taskId: Int, error: Error) {
+    lock.lock()
+    let item = pending.removeValue(forKey: taskId)
+    lock.unlock()
+    item?.continuation.resume(throwing: error)
+  }
+
+  private func fileSize(atPath path: String) -> Int64 {
+    guard let value = try? FileManager.default.attributesOfItem(atPath: path)[.size],
+          let number = value as? NSNumber
+    else {
+      return 0
+    }
+    return number.int64Value
+  }
+}

package/ios/BluetoothSdkModule.swift

@@ -46,6 +46,9 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "settings_ack",
             "version_info",
             "pair_failure",
+            "pairing_info",
+            "entering_pairing_mode",
+            "owner_replaced",
             "audio_pairing_needed",
             "audio_connected",
             "audio_disconnected",
@@ -57,6 +60,7 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             "ws_bin",
             "mic_pcm",
             "mic_lc3",
+            "mic_health",
             "stream_status",
             "keep_alive_ack",
             "mtk_update_complete",
@@ -303,6 +307,11 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             return try await sdk.setHotspotState(enabled: enabled).values
         }
 
+        AsyncFunction("setWifiAdbState") { (enabled: Bool) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            try await sdk.setWifiAdbState(enabled: enabled)
+        }
+
         AsyncFunction("setSystemTime") { (timestampMs: Double) in
             let maxTimestamp = Double(Int64.max).nextDown
             guard timestampMs.isFinite,
@@ -562,6 +571,11 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             ).values
         }
 
+        AsyncFunction("queryVideoRecordingStatus") { (requestId: String) in
+            let sdk = await MainActor.run { self.bluetoothSdk() }
+            return try await sdk.queryVideoRecordingStatus(requestId: requestId).values
+        }
+
         // MARK: - Stream Commands
 
         AsyncFunction("startStream") { (params: [String: Any]) in
@@ -812,6 +826,8 @@ public class BluetoothSdkModule: Module, MentraBluetoothSDKDelegate {
             sendEvent("voice_activity_detection_status", status.values)
         case let .speakingStatus(status):
             sendEvent("speaking_status", status.values)
+        case let .micHealth(health):
+            sendEvent("mic_health", health.values)
         case let .wifiStatus(status):
             sendEvent("wifi_status_change", status.values)
         case let .hotspotStatus(status):
@@ -921,5 +937,3 @@ private extension ConnectOptions {
 
 
 
-
-

package/ios/LocalIPv4.swift

@@ -0,0 +1,150 @@
+import Darwin
+import Foundation
+
+/// Best-effort local IPv4 discovery for phone-hosted servers the glasses reach over WiFi
+/// (photo upload receiver, hotspot-served OTA). Prefers WiFi-ish interfaces carrying RFC1918
+/// addresses — under a glasses-hotspot session en0 holds the 192.168.43.x client address.
+enum LocalIPv4 {
+    /// Return the active Wi-Fi address only when it is on the glasses gateway's /24.
+    /// iPhone Wi-Fi is `en0`; accepting AWDL, VPN, cellular, or another private
+    /// interface can publish an endpoint that the glasses cannot reach.
+    static func wifiIPv4Address(matchingGateway gateway: String) -> String? {
+        guard let gatewayPrefix = subnet24Prefix(gateway) else {
+            return nil
+        }
+
+        var interfaces: UnsafeMutablePointer<ifaddrs>?
+        guard getifaddrs(&interfaces) == 0, let first = interfaces else {
+            return nil
+        }
+        defer { freeifaddrs(interfaces) }
+
+        var cursor: UnsafeMutablePointer<ifaddrs>? = first
+        while let current = cursor {
+            defer { cursor = current.pointee.ifa_next }
+            let interface = current.pointee
+            guard String(cString: interface.ifa_name) == "en0",
+                  let addressPointer = interface.ifa_addr,
+                  addressPointer.pointee.sa_family == UInt8(AF_INET),
+                  (interface.ifa_flags & UInt32(IFF_UP)) != 0
+            else {
+                continue
+            }
+
+            var address = addressPointer.pointee
+            var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+            guard getnameinfo(
+                &address,
+                socklen_t(address.sa_len),
+                &hostname,
+                socklen_t(hostname.count),
+                nil,
+                0,
+                NI_NUMERICHOST
+            ) == 0 else {
+                continue
+            }
+
+            let ip = String(cString: hostname)
+            if subnet24Prefix(ip) == gatewayPrefix {
+                return ip
+            }
+        }
+        return nil
+    }
+
+    static func bestLocalIPv4Address() -> String? {
+        var interfaces: UnsafeMutablePointer<ifaddrs>?
+        guard getifaddrs(&interfaces) == 0, let first = interfaces else {
+            return nil
+        }
+        defer { freeifaddrs(interfaces) }
+
+        var preferredPrivate: String?
+        var preferred: String?
+        var privateFallback: String?
+        var fallback: String?
+        var cursor: UnsafeMutablePointer<ifaddrs>? = first
+        while let current = cursor {
+            defer { cursor = current.pointee.ifa_next }
+            let interface = current.pointee
+            guard let addressPointer = interface.ifa_addr,
+                  addressPointer.pointee.sa_family == UInt8(AF_INET)
+            else {
+                continue
+            }
+
+            let name = String(cString: interface.ifa_name)
+            let flags = interface.ifa_flags
+            guard (flags & UInt32(IFF_UP)) != 0,
+                  (flags & UInt32(IFF_LOOPBACK)) == 0
+            else {
+                continue
+            }
+
+            var address = addressPointer.pointee
+            var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+            let result = getnameinfo(
+                &address,
+                socklen_t(address.sa_len),
+                &hostname,
+                socklen_t(hostname.count),
+                nil,
+                0,
+                NI_NUMERICHOST
+            )
+            guard result == 0 else {
+                continue
+            }
+
+            let ip = String(cString: hostname)
+            guard ip != "127.0.0.1", !isLinkLocalIPv4(ip) else {
+                continue
+            }
+            if isPreferredLocalInterface(name), isPrivateIPv4(ip) {
+                preferredPrivate = preferredPrivate ?? ip
+            } else if isPreferredLocalInterface(name) {
+                preferred = preferred ?? ip
+            } else if isPrivateIPv4(ip) {
+                privateFallback = privateFallback ?? ip
+            } else {
+                fallback = fallback ?? ip
+            }
+        }
+
+        return preferredPrivate ?? preferred ?? privateFallback ?? fallback
+    }
+
+    private static func isPreferredLocalInterface(_ name: String) -> Bool {
+        name == "en0" ||
+            name.hasPrefix("bridge") ||
+            name.hasPrefix("ap") ||
+            name.hasPrefix("awdl") ||
+            name.hasPrefix("llw")
+    }
+
+    private static func isPrivateIPv4(_ ip: String) -> Bool {
+        if ip.hasPrefix("192.168.") || ip.hasPrefix("10.") {
+            return true
+        }
+        let parts = ip.split(separator: ".").compactMap { Int($0) }
+        return parts.count == 4 && parts[0] == 172 && (16 ... 31).contains(parts[1])
+    }
+
+    private static func isLinkLocalIPv4(_ ip: String) -> Bool {
+        ip.hasPrefix("169.254.")
+    }
+
+    private static func subnet24Prefix(_ ip: String) -> String? {
+        let parts = ip.split(separator: ".")
+        guard parts.count == 4,
+              parts.allSatisfy({ part in
+                  guard let value = Int(part) else { return false }
+                  return (0 ... 255).contains(value)
+              })
+        else {
+            return nil
+        }
+        return parts.prefix(3).joined(separator: ".")
+    }
+}

package/ios/LocalOtaServer.swift

@@ -0,0 +1,309 @@
+import Foundation
+import Network
+
+struct OtaServerError: LocalizedError {
+  let message: String
+
+  init(_ message: String) {
+    self.message = message
+  }
+
+  var errorDescription: String? { message }
+}
+
+/// Static HTTP server for hotspot-served glasses OTA (OS-1676).
+///
+/// Serves the rewritten OTA manifest at /version.json and pre-downloaded artifacts at
+/// /artifacts/<sha256> to the glasses over the glasses-hotspot link. Mirrors
+/// LocalPhotoUploadServer's NWListener structure.
+final class LocalOtaServer {
+  private let queue = DispatchQueue(label: "com.mentra.ota-server")
+  private let onLog: (String) -> Void
+  private var listener: NWListener?
+  private var listenerGeneration = 0
+  private(set) var activePort: UInt16?
+
+  private var manifestJson = "{}"
+  private var artifacts: [String: URL] = [:]
+
+  private static let maxHeaderBytes = 64 * 1024
+  private static let streamChunkBytes = 256 * 1024
+
+  init(onLog: @escaping (String) -> Void) {
+    self.onLog = onLog
+  }
+
+  /// Swap the served manifest and artifact set. Safe while the server is running.
+  func configure(manifestJson: String, artifacts: [String: URL]) {
+    queue.sync {
+      self.manifestJson = manifestJson
+      self.artifacts = artifacts
+    }
+  }
+
+  func start(host: String, port: UInt16) throws -> UInt16 {
+    if listener != nil, activePort == port {
+      onLog("Already listening on \(host):\(port)")
+      return port
+    }
+    stop()
+
+    let parameters = NWParameters.tcp
+    parameters.allowLocalEndpointReuse = true
+    guard let endpointPort = NWEndpoint.Port(rawValue: port) else {
+      throw OtaServerError("Invalid port \(port)")
+    }
+
+    parameters.requiredLocalEndpoint = .hostPort(host: NWEndpoint.Host(host), port: endpointPort)
+    let listener = try NWListener(using: parameters)
+    listenerGeneration += 1
+    let generation = listenerGeneration
+    let started = DispatchSemaphore(value: 0)
+    var startError: Error?
+    var isReady = false
+
+    listener.stateUpdateHandler = { [weak self] state in
+      guard let self, self.listenerGeneration == generation else {
+        return
+      }
+      switch state {
+      case .ready:
+        isReady = true
+        self.activePort = port
+        self.onLog("OTA server listening on \(host):\(port)")
+        started.signal()
+      case .failed(let error):
+        startError = error
+        self.activePort = nil
+        self.listener = nil
+        self.onLog("OTA server failed on \(port): \(error)")
+        started.signal()
+      case .cancelled:
+        self.activePort = nil
+        if !isReady {
+          startError = OtaServerError("Listener cancelled")
+          started.signal()
+        }
+      default:
+        break
+      }
+    }
+
+    listener.newConnectionHandler = { [weak self] connection in
+      self?.handle(connection)
+    }
+
+    self.listener = listener
+    listener.start(queue: queue)
+
+    if started.wait(timeout: .now() + 2) == .timedOut {
+      self.listener = nil
+      listener.cancel()
+      throw OtaServerError("Timed out starting listener")
+    }
+    if let startError {
+      self.listener = nil
+      listener.cancel()
+      throw startError
+    }
+
+    return port
+  }
+
+  func stop() {
+    listenerGeneration += 1
+    listener?.cancel()
+    listener = nil
+    activePort = nil
+  }
+
+  private final class RequestReadState {
+    var buffer = Data()
+  }
+
+  private func handle(_ connection: NWConnection) {
+    connection.start(queue: queue)
+    receive(connection, state: RequestReadState())
+  }
+
+  private func receive(_ connection: NWConnection, state: RequestReadState) {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 64 * 1024) {
+      [weak self] data, _, isComplete, error in
+      guard let self else {
+        connection.cancel()
+        return
+      }
+      if let error {
+        self.onLog("request failed: \(error.localizedDescription)")
+        connection.cancel()
+        return
+      }
+      if let data, !data.isEmpty {
+        state.buffer.append(data)
+      }
+
+      if let headerRange = state.buffer.range(of: Data([13, 10, 13, 10])) {
+        let headerData = state.buffer.subdata(in: state.buffer.startIndex..<headerRange.lowerBound)
+        let headerText = String(data: headerData, encoding: .isoLatin1) ?? ""
+        self.route(connection, headerText: headerText)
+        return
+      }
+      if state.buffer.count > Self.maxHeaderBytes {
+        self.writeJson(connection, status: 400, body: #"{"ok":false,"error":"headers_too_large"}"#)
+        return
+      }
+      if isComplete {
+        connection.cancel()
+        return
+      }
+      self.receive(connection, state: state)
+    }
+  }
+
+  private func route(_ connection: NWConnection, headerText: String) {
+    let lines = headerText.components(separatedBy: "\r\n").filter { !$0.isEmpty }
+    let requestParts = lines.first?.components(separatedBy: " ") ?? []
+    let method = requestParts.count > 0 ? requestParts[0].uppercased() : ""
+    let rawPath = requestParts.count > 1 ? requestParts[1] : ""
+    let path = rawPath.components(separatedBy: "?")[0]
+    onLog("\(method) \(path)")
+
+    guard method == "GET" else {
+      writeJson(connection, status: 405, body: #"{"ok":false,"error":"method_not_allowed"}"#)
+      return
+    }
+
+    if path == "/version.json" {
+      writeBody(
+        connection,
+        status: 200,
+        contentType: "application/json",
+        body: Data(manifestJson.utf8)
+      )
+      return
+    }
+
+    if path.hasPrefix("/artifacts/") {
+      let key = String(path.dropFirst("/artifacts/".count))
+      guard let fileUrl = artifacts[key],
+            let fileSize = try? fileUrl.resourceValues(forKeys: [.fileSizeKey]).fileSize
+      else {
+        writeJson(connection, status: 404, body: #"{"ok":false,"error":"artifact_not_found"}"#)
+        return
+      }
+      sendFile(connection, fileUrl: fileUrl, fileLength: Int64(fileSize))
+      return
+    }
+
+    writeJson(connection, status: 404, body: #"{"ok":false,"error":"not_found"}"#)
+  }
+
+  private func sendFile(
+    _ connection: NWConnection,
+    fileUrl: URL,
+    fileLength: Int64
+  ) {
+    let header =
+      "HTTP/1.1 200 OK\r\n" +
+      "Content-Type: application/octet-stream\r\n" +
+      "Content-Length: \(fileLength)\r\n" +
+      "Connection: close\r\n\r\n"
+
+    guard let fileHandle = try? FileHandle(forReadingFrom: fileUrl) else {
+      writeJson(connection, status: 500, body: #"{"ok":false,"error":"artifact_unreadable"}"#)
+      return
+    }
+
+    connection.send(content: Data(header.utf8), completion: .contentProcessed { [weak self] error in
+      guard let self, error == nil else {
+        try? fileHandle.close()
+        connection.cancel()
+        return
+      }
+      self.streamChunks(connection, fileHandle: fileHandle, remaining: fileLength)
+    })
+  }
+
+  private func streamChunks(_ connection: NWConnection, fileHandle: FileHandle, remaining: Int64) {
+    if remaining <= 0 {
+      try? fileHandle.close()
+      connection.send(content: nil, contentContext: .finalMessage, isComplete: true, completion: .contentProcessed { _ in
+        connection.cancel()
+      })
+      return
+    }
+    let chunkSize = Int(min(Int64(Self.streamChunkBytes), remaining))
+    let chunk: Data
+    do {
+      guard let data = try fileHandle.read(upToCount: chunkSize), !data.isEmpty else {
+        throw OtaServerError("artifact truncated while streaming")
+      }
+      chunk = data
+    } catch {
+      onLog("stream failed: \(error.localizedDescription)")
+      try? fileHandle.close()
+      connection.cancel()
+      return
+    }
+    connection.send(content: chunk, completion: .contentProcessed { [weak self] error in
+      guard let self else {
+        try? fileHandle.close()
+        connection.cancel()
+        return
+      }
+      if let error {
+        self.onLog("stream failed: \(error.localizedDescription)")
+        try? fileHandle.close()
+        connection.cancel()
+        return
+      }
+      self.streamChunks(connection, fileHandle: fileHandle, remaining: remaining - Int64(chunk.count))
+    })
+  }
+
+  private func writeJson(
+    _ connection: NWConnection,
+    status: Int,
+    body: String
+  ) {
+    writeBody(
+      connection,
+      status: status,
+      contentType: "application/json",
+      body: Data(body.utf8)
+    )
+  }
+
+  private func writeBody(
+    _ connection: NWConnection,
+    status: Int,
+    contentType: String,
+    body: Data
+  ) {
+    let reason: String
+    switch status {
+    case 200:
+      reason = "OK"
+    case 400:
+      reason = "Bad Request"
+    case 404:
+      reason = "Not Found"
+    case 405:
+      reason = "Method Not Allowed"
+    default:
+      reason = "Internal Server Error"
+    }
+
+    let header =
+      "HTTP/1.1 \(status) \(reason)\r\n" +
+      "Content-Type: \(contentType)\r\n" +
+      "Content-Length: \(body.count)\r\n" +
+      "Connection: close\r\n" +
+      "\r\n"
+    var response = Data(header.utf8)
+    response.append(body)
+    connection.send(content: response, completion: .contentProcessed { _ in
+      connection.cancel()
+    })
+  }
+}

package/ios/MentraBluetoothSDK.podspec

@@ -63,7 +63,11 @@ Pod::Spec.new do |s|
   native_source_files.concat([
     "BluetoothSdkModule.swift",
     "LocalPhotoUploadServer.swift",
-    "MentraPhotoReceiverModule.swift"
+    "MentraPhotoReceiverModule.swift",
+    "LocalIPv4.swift",
+    "LocalOtaServer.swift",
+    "BackgroundOtaArtifactDownloader.swift",
+    "MentraOtaServerModule.swift"
   ]) if include_expo_adapter
   s.source_files = native_source_files