@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/GlasslyBluetoothSDK.podspec

@@ -0,0 +1,106 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+include_expo_adapter = ENV['GLASSLY_BLUETOOTH_SDK_INCLUDE_EXPO_ADAPTER'] == '1'
+
+Pod::Spec.new do |s|
+  s.name           = 'GlasslyBluetoothSDK'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = {
+    :git => 'https://github.com/tetramo-labs/glassly.git',
+    :tag => "bluetooth-sdk-v#{s.version}"
+  }
+  s.static_framework = true
+
+  # External dependencies required by Bluetooth SDK native code
+  s.dependency 'ExpoModulesCore' if include_expo_adapter
+  s.dependency 'SWCompression', '~> 4.8.0'
+  s.dependency 'SwiftProtobuf', '~> 1.0'
+  # Supplies ONNX Runtime for iOS. The vendored sherpa-onnx.xcframework links ORT
+  # *externally*: its only undefined ORT symbol is _OrtGetApiBase, which this pod
+  # provides.
+  #
+  # This version MUST be >= the ORT version sherpa-onnx was built against, and so
+  # must be bumped in lockstep with the xcframework (mirroring the Android pins in
+  # android/build.gradle and android/silero/build.gradle). ORT's C API is backward
+  # compatible but NOT forward compatible: sherpa calls
+  # OrtGetApiBase()->GetApi(ORT_API_VERSION) with the version baked in at its
+  # compile time, and GetApi returns NULL when asked for a version newer than the
+  # runtime provides. sherpa does not null-check that result, so a too-old pod
+  # crashes with EXC_BAD_ACCESS inside the first OrtApi call
+  # (Ort::detail::Global<void>::api is a guarded function-local static, hence the
+  # __cxa_guard_release frame). sherpa-onnx 1.13.4 requests API version 27.
+  #
+  # To re-derive after a future xcframework bump, read the immediate passed to
+  # GetApi (0x1b == 27 for ORT 1.27):
+  #   ar x .../ios-arm64/libsherpa-onnx.a && otool -tvV cat.cc.o | grep -A2 'ldr.*x8, \[x0\]'
+  s.dependency 'onnxruntime-objc', '1.27.0'
+  s.dependency 'UltraliteSDK'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+    'CLANG_CXX_LIBRARY' => 'libc++',
+    'SWIFT_INCLUDE_PATHS' => '$(PODS_TARGET_SRCROOT)/Packages/libbz2'
+  }
+
+  # iOS frameworks required by Bluetooth SDK
+  ios_frameworks = ['AVFoundation', 'CoreBluetooth', 'UIKit', 'CoreGraphics']
+  ios_frameworks << 'Network' if include_expo_adapter
+  s.frameworks = ios_frameworks
+
+  # System libraries required by Glassly
+  # Compression is a .tbd library, not a framework (import Compression autolinks it)
+  s.libraries = 'bz2', 'compression'
+
+  # Vendored frameworks
+  s.vendored_frameworks = 'Packages/SherpaOnnx/sherpa-onnx.xcframework'
+
+  s.resource_bundles = {
+    'BluetoothSDKPrivacy' => ['Source/PrivacyInfo.xcprivacy'],
+    'BluetoothSDKG2Firmware' => ['Source/Resources/G2Firmware/*']
+  }
+
+  native_source_files = [
+    "Source/**/*.{h,m,mm,swift,hpp,cpp,c}",
+    "Packages/CoreObjC/**/*.{h,m,mm,hpp,cpp,c}",
+    "Packages/SherpaOnnx/SherpaOnnx.swift",
+    "Packages/SherpaOnnx/sherpa-onnx.xcframework/ios-arm64/Headers/**/*.{h,hpp}",
+    "Packages/VAD/**/*.swift",
+    "Packages/SherpaOnnx/sherpa-onnx.xcframework/Headers/**/*.{h,hpp}",
+    "Packages/libbz2/shim.h"
+  ]
+  native_source_files.concat([
+    "BluetoothSdkModule.swift",
+    "LocalPhotoUploadServer.swift",
+    "PhotoReceiverModule.swift",
+    "LocalIPv4.swift",
+    "LocalOtaServer.swift",
+    "BackgroundOtaArtifactDownloader.swift",
+    "OtaServerModule.swift"
+  ]) if include_expo_adapter
+  s.source_files = native_source_files
+
+  # Explicitly mark C++ headers and internal headers as private to prevent exposure in public interface
+  s.private_header_files = [
+    "Packages/CoreObjC/lc3_cpp.h",
+    "Packages/CoreObjC/mdct_neon.h",
+    "Packages/CoreObjC/ltpf_neon.h",
+    "Packages/SherpaOnnx/sherpa-onnx.xcframework/ios-arm64/Headers/sherpa-onnx/c-api/cxx-api.h",
+    "Packages/libbz2/shim.h",
+    "Source/Bridging-Header.h"
+  ]
+
+  # Exclude legacy Obj-C bridge files.
+  s.exclude_files = ["Source/BridgeModule.{h,m}", "Source/Bridge.m"]
+end

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.glassly.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()
+    })
+  }
+}