@mentra/glasses-media 3.2.1-dev.314 → 3.3.0-beta.942

package/ios/DecodedFrameTap.swift

@@ -0,0 +1,64 @@
+import CoreVideo
+import Foundation
+
+/// A second, optional consumer of decoded glasses video, sitting beside the ACS sender.
+///
+/// The call owns this pipeline; the preview is a guest. `offer` never blocks, never lets a thrown
+/// error reach its caller, and never does real work — a sink may only decide whether it wants the
+/// frame, retain it, and schedule bounded work elsewhere. The logic lives in
+/// `DecodedFrameTapCore` so it can be unit tested without CoreVideo.
+///
+/// Detach is generation-checked because sessions overlap: a call ending late must not tear down
+/// the subscription a newer call already installed.
+public final class DecodedFrameTap {
+    public static let shared = DecodedFrameTap()
+
+    public typealias Metrics = DecodedFrameTapCore<CVPixelBuffer>.Metrics
+
+    private let core = DecodedFrameTapCore<CVPixelBuffer>()
+
+    public init() {}
+
+    /// Install the preview sink and return the generation that owns it.
+    @discardableResult
+    public func attach(
+        _ sink: @escaping (CVPixelBuffer) throws -> Void,
+        onSinkError: ((Error) -> Void)? = nil
+    ) -> UInt64 {
+        core.attach(sink, onSinkError: onSinkError)
+    }
+
+    /// Remove the sink only if it is still the one this generation installed.
+    @discardableResult
+    public func detach(generation: UInt64) -> Bool {
+        core.detach(generation: generation)
+    }
+
+    public func isCurrent(generation: UInt64) -> Bool {
+        core.isCurrent(generation: generation)
+    }
+
+    public var hasSink: Bool { core.hasSink }
+
+    /// Collect cadence, offer cost and the ACS send count even with no sink attached.
+    public func setTelemetryEnabled(_ enabled: Bool) {
+        core.setTelemetryEnabled(enabled)
+    }
+
+    public var telemetryEnabled: Bool { core.telemetryEnabled }
+
+    /// Read and clear the accumulated observations. Called about once a second by the reporter.
+    public func drainMetrics() -> Metrics {
+        core.drainMetrics()
+    }
+
+    /// The ACS sender accepted a frame. Called by acs-meeting right after a successful send.
+    public func recordAcsSend() {
+        core.recordAcsSend()
+    }
+
+    /// Called on the decoder's thread, immediately before the frame goes to ACS.
+    public func offer(_ buffer: CVPixelBuffer) {
+        core.offer(buffer)
+    }
+}

package/ios/GlassesHotspotNetwork.swift

@@ -4,81 +4,65 @@ import Network
 import NetworkExtension
 import OSLog
 
-/// Same persistent hotspot join as gallery (`joinOnce=false`). Only local traffic uses Wi-Fi.
+/// Shared hotspot association owner. Only local glasses traffic uses Wi-Fi.
 public final class GlassesHotspotNetwork {
     private let logger = Logger(subsystem: "com.mentra.glassesmedia", category: "hotspot")
     private let queue = DispatchQueue(label: "com.mentra.glassesmedia.hotspot")
     private var ssid: String?
     private var lastHotspotSSID: String?
-    private var localAddress: String?
+    /// The verified Wi-Fi interface and DHCP address. Every later check uses this exact pair.
+    private var binding: HotspotInterfaceBinding?
+    private var accessPurpose: HotspotAccessPurpose = .outgoingClient
     private var gatewayAddress: String?
     private var generation = 0
     private var applying = false
     private var ownsConfiguration = false
     private var cancelled = false
     private var joinReply: ((Result<String, Error>) -> Void)?
-    private var leaveReplies: [() -> Void] = []
-    private var monitor: NWPathMonitor?
+    private var leaveReplies: [(Result<Void, Error>) -> Void] = []
+    private var interfaceMonitors: [NWPathMonitor] = []
+    /// Wi-Fi identity learned since this join started; replaced on every join and cleared on leave.
+    private var wifiIdentity = HotspotWifiIdentity()
     private var localAccess: LocalNetworkAccessRequest?
-    #if MENTRA_E2E
-        private var testLeaseConsumed = false
-    #endif
+    private var localAddress: String? {
+        binding?.address
+    }
+
+    private let macWorker = DispatchQueue(label: "com.mentra.glassesmedia.mac-wifi")
+    private var macAssociation: MacHotspotAssociation?
+    private var macAuthorization: MacHotspotAuthorization?
+    private var ownershipToken: UUID?
+    private var finishingLeave = false
     public var onLost: ((String) -> Void)?
     public var onPermissionRequired: (() -> Void)?
     public init() {}
 
-    public func join(ssid: String, passphrase: String, gateway: String? = nil, completion: @escaping (Result<String, Error>) -> Void) {
+    public func join(ssid: String, passphrase: String, gateway: String? = nil, purpose: HotspotAccessPurpose = .outgoingClient, completion: @escaping (Result<String, Error>) -> Void) {
         queue.async {
             guard self.ssid == nil, !self.applying else { completion(.failure(LocalMediaError("Previous hotspot session has not finished cleaning up"))); return }
             if let gateway, !LocalMediaPolicy.isPrivate(gateway) {
                 completion(.failure(LocalMediaError("The glasses reported an invalid hotspot gateway"))); return
             }
+            if ProcessInfo.processInfo.isiOSAppOnMac, gateway == nil {
+                completion(.failure(LocalMediaError("The glasses did not report their hotspot gateway"))); return
+            }
+            guard let token = HotspotNetworkOwnership.shared.acquire() else {
+                completion(.failure(LocalMediaError("The glasses hotspot is already in use"))); return
+            }
+            self.ownershipToken = token
             self.generation += 1
             let gen = self.generation
             self.ssid = ssid
             self.lastHotspotSSID = ssid
             self.gatewayAddress = gateway
+            self.accessPurpose = purpose
             self.cancelled = false
             self.applying = false
             self.ownsConfiguration = false
             self.joinReply = completion
+            self.startInterfaceMonitors(generation: gen)
             if ProcessInfo.processInfo.isiOSAppOnMac {
-                #if MENTRA_E2E
-                    if let raw = ProcessInfo.processInfo.environment["MENTRA_E2E_PREJOINED_HOTSPOT"] {
-                        let address = Self.wifiAddress()
-                        guard !self.testLeaseConsumed,
-                              let lease = try? JSONDecoder().decode(MacE2EHotspotLease.self, from: Data(raw.utf8)),
-                              lease.matches(ssid: ssid, gateway: gateway, address: address, now: Date().timeIntervalSince1970),
-                              let address
-                        else {
-                            self.finishJoin(.failure(LocalMediaError("Mac E2E network lease is invalid, expired or already consumed")))
-                            self.finishLeave()
-                            return
-                        }
-                        self.testLeaseConsumed = true
-                        self.localAddress = address
-                        self.logger.notice("HOTSPOT_JOIN test_harness_connection native_association_untested")
-                        self.startMonitor(generation: gen)
-                        self.waitForLocalAccess(address: address, generation: gen)
-                        return
-                    }
-                #endif
-                NEHotspotNetwork.fetchCurrent { network in
-                    self.queue.async {
-                        guard gen == self.generation, !self.cancelled else { return }
-                        let address = Self.wifiAddress()
-                        if let address, LocalMediaPolicy.canReuseHotspot(requestedSSID: ssid, currentSSID: network?.ssid,
-                                                                         address: address, gateway: gateway)
-                        {
-                            self.localAddress = address
-                            self.logger.info("HOTSPOT_JOIN reuse_verified_macos_connection")
-                            self.startMonitor(generation: gen)
-                            self.waitForLocalAccess(address: address, generation: gen)
-                        } else {
-                            self.applyConfiguration(ssid: ssid, passphrase: passphrase, generation: gen)
-                        }
-                    }
-                }
+                self.authorizeMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen)
             } else {
                 self.applyConfiguration(ssid: ssid, passphrase: passphrase, generation: gen)
             }
@@ -87,6 +71,8 @@ public final class GlassesHotspotNetwork {
                 // Its response time is not a hotspot association timeout.
                 guard gen == self.generation, self.joinReply != nil, self.localAccess == nil else { return }
                 self.cancelled = true
+                self.macAssociation?.cancel()
+                self.macAuthorization?.cancel()
                 self.finishJoin(.failure(LocalMediaError("Hotspot join timed out")))
                 // apply() cannot be cancelled. Retain the reservation until its callback and remove the
                 // late configuration before another call is permitted to acquire the network.
@@ -96,9 +82,11 @@ public final class GlassesHotspotNetwork {
         }
     }
 
-    public func leave(completion: @escaping () -> Void) {
+    public func leave(completion: @escaping (Result<Void, Error>) -> Void) {
         queue.async {
             self.cancelled = true
+            self.macAssociation?.cancel()
+            self.macAuthorization?.cancel()
             self.leaveReplies.append(completion)
             self.finishJoin(.failure(LocalMediaError("Hotspot join cancelled")))
             if let ssid = self.ssid, self.ownsConfiguration { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
@@ -106,6 +94,24 @@ public final class GlassesHotspotNetwork {
         }
     }
 
+    /// The verified hotspot address while its own Wi-Fi interface still holds it; nil after
+    /// loss, leave or an address change. Never falls back to another interface.
+    public func verifiedAddress(completion: @escaping (String?) -> Void) {
+        queue.async {
+            guard let binding = self.binding, !self.cancelled, self.isBindingIntact(binding) else { completion(nil); return }
+            if let association = self.macAssociation {
+                let ssid = self.ssid
+                let gen = self.generation
+                self.macWorker.async {
+                    let matched = (try? association.currentSSID()) == ssid
+                    self.queue.async {
+                        completion(gen == self.generation && !self.cancelled && matched && self.isBindingIntact(binding) ? binding.address : nil)
+                    }
+                }
+            } else { completion(binding.address) }
+        }
+    }
+
     public func info(completion: @escaping ([String: Any]) -> Void) {
         queue.async {
             var value: [String: Any] = ["available": self.localAddress != nil]
@@ -124,7 +130,7 @@ public final class GlassesHotspotNetwork {
             let parameters = NWParameters.tcp
             if ProcessInfo.processInfo.isiOSAppOnMac {
                 // The Mac route probe rejects the Wi-Fi type constraint on an otherwise
-                // usable en0 route. Restrict this connection to the verified source IP.
+                // usable hotspot route. Restrict this connection to the verified source IP.
                 parameters.requiredLocalEndpoint = .hostPort(host: NWEndpoint.Host(address), port: .any)
             } else {
                 parameters.requiredInterfaceType = .wifi
@@ -188,6 +194,72 @@ public final class GlassesHotspotNetwork {
         }
     }
 
+    private func authorizeMacAssociation(ssid: String, passphrase: String, generation gen: Int) {
+        let authorization = MacHotspotAuthorization()
+        macAuthorization = authorization
+        authorization.start { result in
+            self.queue.async {
+                guard gen == self.generation, !self.cancelled else { return }
+                self.macAuthorization = nil
+                switch result {
+                case .success: self.applyMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen)
+                case let .failure(error):
+                    self.finishJoin(.failure(error)); self.finishLeave()
+                }
+            }
+        }
+    }
+
+    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int) {
+        let association = MacHotspotAssociation()
+        macAssociation = association
+        applying = true
+        macWorker.async {
+            let result = Result { try association.associate(ssid: ssid, password: passphrase) }
+            self.queue.async {
+                guard gen == self.generation else { return }
+                self.applying = false
+                if self.cancelled { self.finishLeave(); return }
+                switch result {
+                case let .success(name):
+                    let index = Int(if_nametoindex(name))
+                    guard index > 0 else {
+                        self.finishJoin(.failure(LocalMediaError("Mac Wi-Fi interface disappeared during association")))
+                        self.finishLeave(); return
+                    }
+                    self.wifiIdentity.observe([HotspotInterfaceReport(name: name, index: index, isWifi: true)])
+                    self.waitForMacAddress(ssid: ssid, association: association, generation: gen, remaining: 60)
+                case let .failure(error):
+                    self.finishJoin(.failure(error)); self.finishLeave()
+                }
+            }
+        }
+    }
+
+    private func waitForMacAddress(ssid: String, association: MacHotspotAssociation, generation gen: Int, remaining: Int) {
+        guard gen == generation, !cancelled else { return }
+        macWorker.async {
+            let membership = Result { try association.currentSSID() == ssid }
+            self.queue.async {
+                guard gen == self.generation, !self.cancelled else { return }
+                if case let .failure(error) = membership {
+                    self.finishJoin(.failure(error)); self.finishLeave(); return
+                }
+                if (try? membership.get()) == true, let selected = self.selectBinding() {
+                    self.bind(selected)
+                    self.finishAssociation(address: selected.address, generation: gen)
+                } else if remaining > 0 {
+                    self.queue.asyncAfter(deadline: .now() + 0.5) {
+                        self.waitForMacAddress(ssid: ssid, association: association, generation: gen, remaining: remaining - 1)
+                    }
+                } else {
+                    self.finishJoin(.failure(LocalMediaError("Mac Wi-Fi has no verified glasses hotspot address")))
+                    self.finishLeave()
+                }
+            }
+        }
+    }
+
     private func applyConfiguration(ssid: String, passphrase: String, generation gen: Int) {
         let config = NEHotspotConfiguration(ssid: ssid, passphrase: passphrase, isWEP: false)
         config.joinOnce = false
@@ -221,34 +293,93 @@ public final class GlassesHotspotNetwork {
         NEHotspotNetwork.fetchCurrent { [weak self] network in
             self?.queue.async {
                 guard let self, gen == self.generation, !self.cancelled else { return }
-                if network?.ssid == ssid, let address = Self.wifiAddress(),
-                   self.gatewayAddress.map({ LocalMediaPolicy.isHotspotClientAddress(address, gateway: $0) }) ?? true
-                {
-                    self.localAddress = address
-                    self.startMonitor(generation: gen)
-                    self.waitForLocalAccess(address: address, generation: gen)
+                // The selection applies the BLE gateway's client check when one was reported.
+                if network?.ssid == ssid, let selected = self.selectBinding() {
+                    self.bind(selected)
+                    self.finishAssociation(address: selected.address, generation: gen)
                 } else if remaining > 0 {
                     self.queue.asyncAfter(deadline: .now() + 0.5) { self.waitForAddress(ssid: ssid, generation: gen, remaining: remaining - 1) }
                 } else {
                     let association = network == nil ? "unavailable" : (network?.ssid == ssid ? "matched" : "different")
-                    let address = Self.wifiAddress() ?? "none"
-                    self.finishJoin(.failure(LocalMediaError("Glasses hotspot has no verified Wi-Fi address (SSID=\(association), Wi-Fi IPv4=\(address))")))
+                    self.finishJoin(.failure(LocalMediaError("Glasses hotspot has no verified Wi-Fi address (SSID=\(association), \(self.wifiDiagnostic()))")))
                     self.finishLeave()
                 }
             }
         }
     }
 
-    private func startMonitor(generation gen: Int) {
-        let monitor = NWPathMonitor(requiredInterfaceType: .wifi)
-        self.monitor = monitor
-        monitor.pathUpdateHandler = { [weak self] _ in
-            guard let self, gen == generation, !self.cancelled else { return }
-            // This AP intentionally has no internet. Loss of its default internet path is not
-            // loss of the local link; use the actual interface address instead.
-            if Self.wifiAddress() != localAddress { onLost?("Glasses hotspot connection was lost") }
+    /// iOS can omit an internet-less Wi-Fi from its default path, and iOS-on-Mac has rejected
+    /// a Wi-Fi type constraint on a usable hotspot route. Both paths' interface types feed one
+    /// session identity (HotspotWifiIdentity): a positive Wi-Fi report outlives later omission
+    /// only while the same interface stays attached; contrary reports and replacement fail closed.
+    /// A phone that starts on cellular never gets a report; HotspotInterfacePolicy then uses
+    /// the hotspot client address as the evidence.
+    private func startInterfaceMonitors(generation gen: Int) {
+        interfaceMonitors.forEach { $0.cancel() }
+        let monitors = [NWPathMonitor(requiredInterfaceType: .wifi), NWPathMonitor()]
+        interfaceMonitors = monitors
+        wifiIdentity = HotspotWifiIdentity()
+        for monitor in monitors {
+            monitor.pathUpdateHandler = { [weak self] path in
+                guard let self, gen == self.generation else { return }
+                self.wifiIdentity.observe(path.availableInterfaces.map {
+                    HotspotInterfaceReport(name: $0.name, index: $0.index, isWifi: $0.type == .wifi)
+                })
+                // This AP intentionally has no internet. Loss of its default internet path is not
+                // loss of the local link; check the verified interface and address instead.
+                if let binding = self.binding, !self.cancelled, !self.isBindingIntact(binding) {
+                    self.onLost?("Glasses hotspot connection was lost")
+                }
+            }
+            monitor.start(queue: queue)
+        }
+    }
+
+    /// Every check samples interfaces first, so a detach or replacement between path updates
+    /// is recorded in the session identity before it is used.
+    private func observeInterfaces() -> HotspotInterfaceSnapshot {
+        let snapshot = Self.interfaceSnapshot()
+        wifiIdentity.observe(snapshot)
+        return snapshot
+    }
+
+    private func selectBinding() -> HotspotInterfaceBinding? {
+        HotspotInterfacePolicy.select(snapshot: observeInterfaces(), identity: wifiIdentity, gateway: gatewayAddress)
+    }
+
+    private func isBindingIntact(_ binding: HotspotInterfaceBinding) -> Bool {
+        let snapshot = observeInterfaces()
+        return HotspotInterfacePolicy.isIntact(binding, snapshot: snapshot, identity: wifiIdentity)
+    }
+
+    private func bind(_ selected: HotspotInterfaceBinding) {
+        let evidence = wifiIdentity.trusted[selected.interface] == selected.index ? "wifi_report" : "hotspot_client"
+        wifiIdentity.adopt(selected)
+        binding = selected
+        logger.info("HOTSPOT_JOIN address_verified interface=\(selected.interface, privacy: .public) evidence=\(evidence, privacy: .public)")
+    }
+
+    /// Interface names and their IPv4 addresses only; never credentials or SSIDs.
+    private func wifiDiagnostic() -> String {
+        let snapshot = observeInterfaces()
+        let wifi = Set(wifiIdentity.trusted.keys)
+        let addresses = snapshot.addresses.filter { wifi.contains($0.name) }.map { "\($0.name)=\($0.ipv4)" }
+        let other = snapshot.addresses.filter { !wifi.contains($0.name) && LocalMediaPolicy.isPrivate($0.ipv4) }
+            .map { "\($0.name)\(snapshot.ethernetLinks.contains($0.name) ? "" : "(non-ethernet)")=\($0.ipv4)" }
+        return "Wi-Fi interfaces=\(wifi.isEmpty ? "none" : wifi.sorted().joined(separator: ",")), " +
+            "Wi-Fi IPv4=\(addresses.isEmpty ? "none" : addresses.sorted().joined(separator: ",")), " +
+            "other private IPv4=\(other.isEmpty ? "none" : other.sorted().joined(separator: ","))"
+    }
+
+    private func finishAssociation(address: String, generation gen: Int) {
+        // OTA serves incoming TCP. Its native listener proves server readiness; dialing
+        // the glasses' unrelated Gallery server would add a client permission dependency.
+        // TN3179: accepting incoming TCP does not require Local Network access.
+        if accessPurpose == .incomingServer {
+            finishJoin(.success(address))
+        } else {
+            waitForLocalAccess(address: address, generation: gen)
         }
-        monitor.start(queue: queue)
     }
 
     private func waitForLocalAccess(address: String, generation gen: Int) {
@@ -279,34 +410,84 @@ public final class GlassesHotspotNetwork {
     }
 
     private func finishLeave() {
+        guard !finishingLeave else { return }
+        finishingLeave = true
+        if let association = macAssociation {
+            association.cancel()
+            // This queue is also the association queue: cleanup cannot overtake
+            // a blocking scan/join, and process-wide ownership remains held.
+            macWorker.async {
+                let result = Result { try association.leave() }
+                self.queue.async {
+                    switch result {
+                    case .success:
+                        self.macAssociation = nil
+                        self.completeLeave()
+                    case let .failure(error):
+                        // Retain the owner when we cannot prove which association
+                        // cleanup would disconnect. A later leave can retry safely.
+                        self.finishingLeave = false
+                        let replies = self.leaveReplies
+                        self.leaveReplies.removeAll()
+                        replies.forEach { $0(.failure(error)) }
+                    }
+                }
+            }
+        } else { completeLeave() }
+    }
+
+    private func completeLeave() {
         generation += 1
+        macAuthorization?.cancel(); macAuthorization = nil
         localAccess?.cancel(); localAccess = nil
-        monitor?.cancel(); monitor = nil
+        interfaceMonitors.forEach { $0.cancel() }
+        interfaceMonitors = []
+        wifiIdentity = HotspotWifiIdentity()
         if let ssid, ownsConfiguration { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
         ownsConfiguration = false
         ssid = nil
-        localAddress = nil
+        binding = nil
         gatewayAddress = nil
+        finishingLeave = false
+        if let token = ownershipToken { HotspotNetworkOwnership.shared.release(token) }
+        ownershipToken = nil
         let replies = leaveReplies
         leaveReplies.removeAll()
-        replies.forEach { $0() }
+        replies.forEach { $0(.success(())) }
     }
 
-    public static func wifiAddress() -> String? {
+    /// Every attached interface's kernel index and link type (its AF_LINK row) and every IPv4
+    /// address with its interface name and up state. Selection belongs to HotspotInterfacePolicy;
+    /// an interface name alone never identifies Wi-Fi. A failed read yields an empty sample, which
+    /// fails closed.
+    static func interfaceSnapshot() -> HotspotInterfaceSnapshot {
         var interfaces: UnsafeMutablePointer<ifaddrs>?
-        guard getifaddrs(&interfaces) == 0 else { return nil }
+        guard getifaddrs(&interfaces) == 0 else { return HotspotInterfaceSnapshot(links: [:], addresses: []) }
         defer { freeifaddrs(interfaces) }
+        var links: [String: Int] = [:]
+        var ethernetLinks: Set<String> = []
+        var rows: [HotspotInterfaceAddress] = []
         var cursor = interfaces
         while let item = cursor {
             defer { cursor = item.pointee.ifa_next }
             let value = item.pointee
-            guard String(cString: value.ifa_name) == "en0", value.ifa_flags & UInt32(IFF_UP) != 0,
-                  let address = value.ifa_addr, address.pointee.sa_family == UInt8(AF_INET) else { continue }
+            guard let address = value.ifa_addr else { continue }
+            let name = String(cString: value.ifa_name)
+            if address.pointee.sa_family == UInt8(AF_LINK) {
+                let (index, type) = address.withMemoryRebound(to: sockaddr_dl.self, capacity: 1) {
+                    (Int($0.pointee.sdl_index), Int32($0.pointee.sdl_type))
+                }
+                if index > 0 {
+                    links[name] = index
+                    if type == IFT_ETHER { ethernetLinks.insert(name) }
+                }
+                continue
+            }
+            guard address.pointee.sa_family == UInt8(AF_INET) else { continue }
             var host = [CChar](repeating: 0, count: Int(NI_MAXHOST))
             guard getnameinfo(address, socklen_t(address.pointee.sa_len), &host, socklen_t(host.count), nil, 0, NI_NUMERICHOST) == 0 else { continue }
-            let ip = String(cString: host)
-            if LocalMediaPolicy.isPrivate(ip) { return ip }
+            rows.append(HotspotInterfaceAddress(name: name, isUp: value.ifa_flags & UInt32(IFF_UP) != 0, ipv4: String(cString: host)))
         }
-        return nil
+        return HotspotInterfaceSnapshot(links: links, addresses: rows, ethernetLinks: ethernetLinks)
     }
 }

package/ios/GlassesMedia.podspec

@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
   s.dependency 'ExpoModulesCore'
   # Keep in sync with the iOS-only @livekit/react-native-webrtc podspec patch.
   s.dependency 'WebRTC-SDK', '144.7559.15'
-  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'Network', 'NetworkExtension'
+  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'CoreLocation', 'Network', 'NetworkExtension'
   s.source_files = '*.{swift,h,m,mm}', 'CoreKit/Sources/GlassesMediaCore/*.swift'
   s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
 end

package/ios/GlassesMediaRelayModule.swift

@@ -4,11 +4,49 @@ import Foundation
 public final class GlassesMediaRelayModule: Module {
     private let queue = DispatchQueue(label: "com.mentra.glassesmedia.relay")
     private var session: ManagedRelaySession?
+    private let localHotspot = GlassesHotspotNetwork()
+    private var localHotspotOwner: String?
 
     public func definition() -> ModuleDefinition {
         Name("MentraGlassesMediaRelay")
         Events("onRelayState")
 
+        AsyncFunction("joinLocalHotspot") { (id: String, ssid: String, password: String, gateway: String?, purpose: String, promise: Promise) in
+            self.queue.async {
+                guard self.localHotspotOwner == nil else {
+                    promise.reject(LocalMediaError("Previous hotspot session has not been released")); return
+                }
+                guard let accessPurpose = HotspotAccessPurpose(rawValue: purpose) else {
+                    promise.reject(LocalMediaError("Invalid hotspot access purpose")); return
+                }
+                self.localHotspotOwner = id
+                self.localHotspot.join(ssid: ssid, passphrase: password, gateway: gateway, purpose: accessPurpose) { result in
+                    switch result {
+                    case let .success(address): promise.resolve(address)
+                    case let .failure(error):
+                        let failure = HotspotJoinFailure(error)
+                        promise.reject(Exception(name: "HotspotJoinFailure", description: failure.message, code: failure.code))
+                    }
+                }
+            }
+        }
+
+        AsyncFunction("leaveLocalHotspot") { (id: String, promise: Promise) in
+            self.queue.async {
+                guard self.localHotspotOwner == id else { promise.resolve(nil); return }
+                self.localHotspot.leave { result in
+                    self.queue.async {
+                        switch result {
+                        case .success:
+                            if self.localHotspotOwner == id { self.localHotspotOwner = nil }
+                            promise.resolve(nil)
+                        case let .failure(error): promise.reject(error)
+                        }
+                    }
+                }
+            }
+        }
+
         AsyncFunction("prepare") { (options: [String: Any], promise: Promise) in
             guard let id = options["attemptId"] as? String,
                   let ingest = options["ingestUrl"] as? String, let url = URL(string: ingest), url.scheme == "https",
@@ -38,16 +76,23 @@ public final class GlassesMediaRelayModule: Module {
         AsyncFunction("stop") { (id: String, promise: Promise) in
             self.queue.async {
                 guard let session = self.session, session.id == id else { promise.resolve(nil); return }
-                session.stop {
-                    if self.session === session { self.session = nil }
-                    promise.resolve(nil)
+                session.stop { result in
+                    switch result {
+                    case .success:
+                        if self.session === session { self.session = nil }
+                        promise.resolve(nil)
+                    case let .failure(error): promise.reject(error)
+                    }
                 }
             }
         }
 
         OnDestroy {
             self.queue.async {
-                self.session?.stop { self.session = nil }
+                self.session?.stop { result in
+                    if case .success = result { self.session = nil }
+                }
+                self.localHotspot.leave { _ in }
             }
         }
     }
@@ -62,7 +107,7 @@ private final class ManagedRelaySession {
     private var publisher: PhoneWhipPublisher?
     private var stopped = false
     private var stopFinished = false
-    private var stopReplies: [() -> Void] = []
+    private var stopReplies: [(Result<Void, Error>) -> Void] = []
     private var ready: ((Result<String, Error>) -> Void)?
 
     init(id: String, queue: DispatchQueue) {
@@ -116,10 +161,11 @@ private final class ManagedRelaySession {
         let callback = ready; ready = nil; callback?(result)
     }
 
-    func stop(completion: @escaping () -> Void) {
-        if stopFinished { completion(); return }
+    func stop(completion: @escaping (Result<Void, Error>) -> Void) {
+        if stopFinished { completion(.success(())); return }
+        let stopping = !stopReplies.isEmpty
         stopReplies.append(completion)
-        guard !stopped else { return }
+        guard !stopping else { return }
         stopped = true
         finish(.failure(LocalMediaError("Relay cancelled")))
         hotspot.onLost = nil
@@ -131,10 +177,14 @@ private final class ManagedRelaySession {
         if let publisher {
             group.enter(); publisher.stop { group.leave() }
         }
-        group.enter(); hotspot.leave { group.leave() }
+        var cleanupResult: Result<Void, Error> = .success(())
+        group.enter(); hotspot.leave { result in
+            self.queue.async { cleanupResult = result; group.leave() }
+        }
         group.notify(queue: queue) {
-            self.receiver = nil; self.publisher = nil; self.stopFinished = true
-            let replies = self.stopReplies; self.stopReplies.removeAll(); replies.forEach { $0() }
+            self.receiver = nil; self.publisher = nil
+            if case .success = cleanupResult { self.stopFinished = true }
+            let replies = self.stopReplies; self.stopReplies.removeAll(); replies.forEach { $0(cleanupResult) }
         }
     }
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@mentra/glasses-media",
-  "version": "3.2.1-dev.314",
+  "version": "3.3.0-beta.942",
   "description": "Shared native glasses media receivers and local network transport",
   "license": "MIT",
   "author": "Mentra Community",
   "homepage": "https://github.com/Mentra-Community/MentraOS",
   "main": "index.js",
+  "types": "index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Mentra-Community/MentraOS.git",
@@ -14,8 +15,12 @@
   "publishConfig": {
     "access": "public"
   },
+  "peerDependencies": {
+    "expo-modules-core": "~55.0.25"
+  },
   "files": [
     "index.js",
+    "index.d.ts",
     "expo-module.config.json",
     "android/build.gradle",
     "android/src/main",