@mentra/bluetooth-sdk 0.1.21-beta.5 → 3.1.0-dev.7

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
 

package/ios/MentraOtaServerModule.swift

@@ -0,0 +1,147 @@
+import ExpoModulesCore
+import Foundation
+
+/// Expo surface for the hotspot-served OTA file server (OS-1676).
+///
+/// JS hands over the rewritten manifest body and a map of sha256 -> local file path, and gets
+/// back the base URL the glasses should be pointed at via ota_start. The optional host
+/// argument lets the caller pass an authoritative address; otherwise interface scanning is
+/// used (under a glasses-hotspot session en0 holds the hotspot client address).
+public class MentraOtaServerModule: Module {
+    private let serverLock = NSLock()
+    private var otaServer: LocalOtaServer?
+    private lazy var artifactDownloader = BackgroundOtaArtifactDownloader { [weak self] destination, written, total in
+        self?.sendEvent("artifactDownloadProgress", [
+            "destination": destination,
+            "bytesWritten": written,
+            "contentLength": total,
+        ])
+    }
+
+    public func definition() -> ModuleDefinition {
+        Name("MentraOtaServer")
+
+        Events("artifactDownloadProgress")
+
+        AsyncFunction("startOtaServer") { (manifestJson: String, artifactPaths: [String: String], host: String?) -> [String: Any] in
+            try self.startOtaServer(manifestJson: manifestJson, artifactPaths: artifactPaths, hostOverride: host)
+        }
+
+        AsyncFunction("stopOtaServer") {
+            self.stopOtaServerInternal()
+        }
+
+        AsyncFunction("waitForWifiAddress") { (gateway: String, timeoutMs: Int) -> String in
+            try await self.waitForWifiAddress(gateway: gateway, timeoutMs: timeoutMs)
+        }
+
+        AsyncFunction("downloadArtifact") { (source: String, destination: String) in
+            try await self.artifactDownloader.download(from: source, to: destination)
+        }
+
+        OnDestroy {
+            self.stopOtaServerInternal()
+        }
+    }
+
+    private func startOtaServer(
+        manifestJson: String,
+        artifactPaths: [String: String],
+        hostOverride: String?
+    ) throws -> [String: Any] {
+        serverLock.lock()
+        defer { serverLock.unlock() }
+
+        var artifacts: [String: URL] = [:]
+        for (key, path) in artifactPaths {
+            let url = path.hasPrefix("file://")
+                ? (URL(string: path) ?? URL(fileURLWithPath: String(path.dropFirst("file://".count))))
+                : URL(fileURLWithPath: path)
+            guard FileManager.default.fileExists(atPath: url.path) else {
+                throw OtaServerModuleError("Artifact \(key) not found at \(url.path)")
+            }
+            artifacts[key] = url
+        }
+
+        guard let host = hostOverride?.isEmpty == false ? hostOverride : LocalIPv4.bestLocalIPv4Address() else {
+            throw OtaServerModuleError("No Wi-Fi/LAN IPv4 address found for this phone.")
+        }
+
+        let server = otaServer ?? LocalOtaServer(
+            onLog: { [weak self] message in
+                self?.emitStatus(message: message)
+            }
+        )
+        otaServer = server
+        server.configure(manifestJson: manifestJson, artifacts: artifacts)
+
+        if let activePort = server.activePort {
+            emitStatus(message: "OTA server ready at http://\(host):\(activePort)/version.json")
+            return serverResult(host: host, port: activePort)
+        }
+
+        var lastError: Error?
+        for port in otaPorts {
+            do {
+                let actualPort = try server.start(host: host, port: UInt16(port))
+                emitStatus(message: "OTA server ready at http://\(host):\(actualPort)/version.json")
+                return serverResult(host: host, port: actualPort)
+            } catch {
+                lastError = error
+                emitStatus(message: "Port \(port) unavailable: \(error.localizedDescription)")
+            }
+        }
+
+        throw OtaServerModuleError(
+            "Could not start OTA server: \(lastError?.localizedDescription ?? "all ports unavailable")"
+        )
+    }
+
+    private func waitForWifiAddress(gateway: String, timeoutMs: Int) async throws -> String {
+        let deadline = Date().addingTimeInterval(Double(max(timeoutMs, 0)) / 1000.0)
+        repeat {
+            if let address = LocalIPv4.wifiIPv4Address(matchingGateway: gateway) {
+                return address
+            }
+            try await Task.sleep(nanoseconds: 250_000_000)
+        } while Date() < deadline
+
+        throw OtaServerModuleError("The iPhone did not join the glasses hotspot subnet.")
+    }
+
+    private func stopOtaServerInternal() {
+        serverLock.lock()
+        defer { serverLock.unlock() }
+
+        otaServer?.stop()
+        emitStatus(message: "OTA server stopped")
+    }
+
+    private func emitStatus(message: String) {
+        NSLog("[MentraOtaServer] %@", message)
+    }
+
+    private func serverResult(host: String, port: UInt16) -> [String: Any] {
+        [
+            "baseUrl": "http://\(host):\(port)",
+            "manifestUrl": "http://\(host):\(port)/version.json",
+            "host": host,
+            "port": port,
+        ]
+    }
+
+    private let otaPorts = [8791, 8792, 8793, 8794]
+}
+
+final class OtaServerModuleError: Exception, @unchecked Sendable {
+    private let message: String
+
+    init(_ message: String) {
+        self.message = message
+        super.init()
+    }
+
+    override var reason: String {
+        message
+    }
+}