@mentra/glasses-media 3.4.0-dev.950 → 3.4.0-dev.951

package/index.d.ts

@@ -7,5 +7,5 @@ export const glassesHotspot: {
     gateway?: string,
     purpose?: "outgoing-client" | "incoming-server",
   ): Promise<string>
-  leave(id: string): Promise<void>
+  leave(id: string, waitForInternet?: boolean): Promise<void>
 }

package/index.js

@@ -6,5 +6,5 @@ const native = () => require("expo-modules-core").requireNativeModule("MentraGla
 export const glassesHotspot = Object.freeze({
   join: (id, ssid, password, gateway, purpose = "outgoing-client") =>
     native().joinLocalHotspot(id, ssid, password, gateway ?? null, purpose),
-  leave: (id) => native().leaveLocalHotspot(id),
+  leave: (id, waitForInternet = false) => native().leaveLocalHotspot(id, waitForInternet),
 })

package/ios/CoreKit/Sources/GlassesMediaCore/HotspotInternetPolicy.swift

@@ -8,9 +8,106 @@ public enum HotspotInternetPolicy {
         if cellular { return "cellular" }
         if ethernet { return "ethernet" }
         // Callers supply a Wi-Fi SSID only after releasing the glasses hotspot.
-        if let restoredWifiSSID, !restoredWifiSSID.isEmpty, restoredWifiSSID != glassesSSID {
+        if let restoredWifiSSID, let glassesSSID, !glassesSSID.isEmpty, !restoredWifiSSID.isEmpty, restoredWifiSSID != glassesSSID {
             return "wifi"
         }
         return nil
     }
 }
+
+/// One queue-confined route observation. Late SSID callbacks cannot settle a
+/// newer path or session, and timeout/cancellation settle this observation once.
+public final class HotspotInternetObservation {
+    private let generation: Int
+    private let glassesSSID: String?
+    private var pathRevision = 0
+    private var finished = false
+    private var readingSSID = false
+    private var settledReply: (() -> Void)?
+
+    public init(generation: Int, glassesSSID: String?) {
+        self.generation = generation
+        self.glassesSSID = glassesSSID
+    }
+
+    public func beginPath(currentGeneration: Int) -> Int? {
+        guard !finished, currentGeneration == generation else { return nil }
+        pathRevision += 1
+        return pathRevision
+    }
+
+    public func restoredWifiRoute(ssid: String?, pathRevision: Int, currentGeneration: Int) -> String? {
+        guard !finished, currentGeneration == generation, pathRevision == self.pathRevision else { return nil }
+        return HotspotInternetPolicy.route(satisfied: true, cellular: false, ethernet: false,
+                                           restoredWifiSSID: ssid, glassesSSID: glassesSSID)
+    }
+
+    public func beginSSIDRead() -> Bool {
+        guard !finished, !readingSSID else { return false }
+        readingSSID = true
+        return true
+    }
+
+    public func completeSSIDRead() {
+        readingSSID = false
+        let reply = settledReply
+        settledReply = nil
+        reply?()
+    }
+
+    public func afterSSIDRead(_ reply: @escaping () -> Void) {
+        if readingSSID { settledReply = reply } else { reply() }
+    }
+
+    public func settle() -> Bool {
+        guard !finished else { return false }
+        finished = true
+        return true
+    }
+}
+
+/// Queue-confined cancellation owner. An old observation may finish joining its
+/// native read after its replacement starts, but cannot clear that replacement.
+public final class HotspotInternetObservationOwner {
+    private var current: (observation: HotspotInternetObservation, cancel: () -> Void)?
+
+    public init() {}
+
+    public func install(_ observation: HotspotInternetObservation, cancel: @escaping () -> Void) {
+        current?.cancel()
+        current = (observation, cancel)
+    }
+
+    public func clear(_ observation: HotspotInternetObservation) {
+        if current?.observation === observation { current = nil }
+    }
+
+    public func cancel() {
+        current?.cancel()
+    }
+}
+
+/// Queue-confined completion of one leave. Concurrent callers share cleanup;
+/// the original ownership token is released before any caller can start again.
+public final class HotspotLeaveCompletion {
+    private var replies: [(Result<Void, Error>) -> Void] = []
+    private var pending = true
+    private let release: () -> Void
+
+    public init(release: @escaping () -> Void) {
+        self.release = release
+    }
+
+    public func append(_ reply: @escaping (Result<Void, Error>) -> Void) {
+        replies.append(reply)
+    }
+
+    public func complete(_ result: Result<Void, Error>) {
+        guard pending else { return }
+        pending = false
+        if case .success = result { release() }
+        let current = replies
+        replies.removeAll()
+        current.forEach { $0(result) }
+    }
+}

package/ios/CoreKit/Sources/GlassesMediaCore/MacHotspotAssociation.swift

@@ -5,13 +5,23 @@ import ObjectiveC
 /// Blocking public CoreWLAN calls are isolated here; the existing hotspot owner
 /// retains custody until they return, even after cancellation or a timeout.
 final class MacHotspotAssociation {
-    private let lock = NSLock()
+    private let condition = NSCondition()
     private var cancelled = false
     private var interface: MacWifiInterface?
     private var joinedSSID: String?
+    private let deadline: TimeInterval
+    private let now: () -> TimeInterval
+    private let pause: ((TimeInterval) -> Void)?
     private let makeInterface: () throws -> MacWifiInterface
 
-    init(makeInterface: @escaping () throws -> MacWifiInterface = { try PublicCoreWlanInterface() }) {
+    init(deadline: TimeInterval = ProcessInfo.processInfo.systemUptime + 60,
+         now: @escaping () -> TimeInterval = { ProcessInfo.processInfo.systemUptime },
+         pause: ((TimeInterval) -> Void)? = nil,
+         makeInterface: @escaping () throws -> MacWifiInterface = { try PublicCoreWlanInterface() })
+    {
+        self.deadline = deadline
+        self.now = now
+        self.pause = pause
         self.makeInterface = makeInterface
     }
 
@@ -20,12 +30,15 @@ final class MacHotspotAssociation {
         let interface = try makeInterface()
         self.interface = interface
         if try interface.currentSSID() != ssid {
-            let network = try interface.network(ssid: ssid)
-            try checkCurrent()
-            // Record the intended association before this blocking call. A late
-            // successful join still belongs to us and must be cleaned up.
-            joinedSSID = ssid
-            try interface.associate(network: network, password: password)
+            let network = try discoverNetwork(ssid: ssid, interface: interface)
+            try checkDiscoveryCurrent()
+            if let network, try interface.currentSSID() != ssid {
+                try checkDiscoveryCurrent()
+                // Record the intended association before this blocking call. A late
+                // successful join still belongs to us and must be cleaned up.
+                joinedSSID = ssid
+                try interface.associate(network: network, password: password)
+            }
         }
         try checkCurrent()
         guard try interface.currentSSID() == ssid else {
@@ -35,7 +48,7 @@ final class MacHotspotAssociation {
     }
 
     func cancel() {
-        lock.lock(); cancelled = true; lock.unlock()
+        condition.lock(); cancelled = true; condition.broadcast(); condition.unlock()
     }
 
     /// Run on the same worker as association, after its blocking call returns.
@@ -57,8 +70,40 @@ final class MacHotspotAssociation {
         try interface?.currentSSID()
     }
 
+    static func observeCurrentSSID() throws -> String? {
+        try PublicCoreWlanInterface().currentSSID()
+    }
+
+    private func discoverNetwork(ssid: String, interface: MacWifiInterface) throws -> NSObject? {
+        while true {
+            try checkDiscoveryCurrent()
+            // Recheck Location authorization before and after each blocking scan.
+            if try interface.currentSSID() == ssid { return nil }
+            let network = try interface.network(ssid: ssid)
+            try checkDiscoveryCurrent()
+            if try interface.currentSSID() == ssid { return nil }
+            if let network { return network }
+            // Successful empty scans remain pending within this same join window.
+            // Native scan errors escape immediately; association is never retried.
+            let remaining = max(0, deadline - now())
+            if let pause { pause(min(1, remaining)) }
+            else {
+                condition.lock()
+                if !cancelled { _ = condition.wait(until: Date(timeIntervalSinceNow: min(1, remaining))) }
+                condition.unlock()
+            }
+        }
+    }
+
+    private func checkDiscoveryCurrent() throws {
+        try checkCurrent()
+        guard now() < deadline else {
+            throw LocalMediaError("The requested glasses hotspot was not found by Mac Wi-Fi before the hotspot join timed out")
+        }
+    }
+
     private func checkCurrent() throws {
-        lock.lock(); let stopped = cancelled; lock.unlock()
+        condition.lock(); let stopped = cancelled; condition.unlock()
         if stopped { throw CancellationError() }
     }
 }
@@ -66,7 +111,7 @@ final class MacHotspotAssociation {
 protocol MacWifiInterface: AnyObject {
     func name() throws -> String
     func currentSSID() throws -> String?
-    func network(ssid: String) throws -> NSObject
+    func network(ssid: String) throws -> NSObject?
     func associate(network: NSObject, password: String) throws
     func disassociate()
 }
@@ -122,7 +167,7 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
         return String(data: data, encoding: .utf8)
     }
 
-    func network(ssid: String) throws -> NSObject {
+    func network(ssid: String) throws -> NSObject? {
         let selector = NSSelectorFromString("scanForNetworksWithSSID:error:")
         let invoke = unsafeBitCast(interface.method(for: selector), to: MacWifiInvocation.Scan.self)
         var error: NSError?
@@ -137,7 +182,7 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
                   data == Data(ssid.utf8) else { continue }
             return network
         }
-        throw LocalMediaError("The requested glasses hotspot was not found by Mac Wi-Fi")
+        return nil
     }
 
     func associate(network: NSObject, password: String) throws {

package/ios/GlassesHotspotNetwork.swift

@@ -19,7 +19,7 @@ public final class GlassesHotspotNetwork {
     private var ownsConfiguration = false
     private var cancelled = false
     private var joinReply: ((Result<String, Error>) -> Void)?
-    private var leaveReplies: [(Result<Void, Error>) -> Void] = []
+    private var leaveCompletion: HotspotLeaveCompletion?
     private var interfaceMonitors: [NWPathMonitor] = []
     /// Wi-Fi identity learned since this join started; replaced on every join and cleared on leave.
     private var wifiIdentity = HotspotWifiIdentity()
@@ -33,6 +33,8 @@ public final class GlassesHotspotNetwork {
     private var macAuthorization: MacHotspotAuthorization?
     private var ownershipToken: UUID?
     private var finishingLeave = false
+    private var waitForInternetAfterLeave = false
+    private let internetObservationOwner = HotspotInternetObservationOwner()
     public var onLost: ((String) -> Void)?
     public var onPermissionRequired: (() -> Void)?
     public init() {}
@@ -52,6 +54,7 @@ public final class GlassesHotspotNetwork {
             self.ownershipToken = token
             self.generation += 1
             let gen = self.generation
+            let deadline = ProcessInfo.processInfo.systemUptime + 60
             self.ssid = ssid
             self.lastHotspotSSID = ssid
             self.gatewayAddress = gateway
@@ -62,11 +65,11 @@ public final class GlassesHotspotNetwork {
             self.joinReply = completion
             self.startInterfaceMonitors(generation: gen)
             if ProcessInfo.processInfo.isiOSAppOnMac {
-                self.authorizeMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen)
+                self.authorizeMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen, deadline: deadline)
             } else {
                 self.applyConfiguration(ssid: ssid, passphrase: passphrase, generation: gen)
             }
-            self.queue.asyncAfter(deadline: .now() + 60) {
+            self.queue.asyncAfter(deadline: .now() + max(0, deadline - ProcessInfo.processInfo.systemUptime)) {
                 // Once associated, the user may still be reading the Local Network alert.
                 // Its response time is not a hotspot association timeout.
                 guard gen == self.generation, self.joinReply != nil, self.localAccess == nil else { return }
@@ -82,12 +85,20 @@ public final class GlassesHotspotNetwork {
         }
     }
 
-    public func leave(completion: @escaping (Result<Void, Error>) -> Void) {
+    public func leave(waitForInternet: Bool = false, completion: @escaping (Result<Void, Error>) -> Void) {
         queue.async {
+            if !waitForInternet { self.internetObservationOwner.cancel() }
+            self.waitForInternetAfterLeave = self.waitForInternetAfterLeave || waitForInternet
             self.cancelled = true
             self.macAssociation?.cancel()
             self.macAuthorization?.cancel()
-            self.leaveReplies.append(completion)
+            if self.leaveCompletion == nil {
+                self.leaveCompletion = HotspotLeaveCompletion {
+                    if let token = self.ownershipToken { HotspotNetworkOwnership.shared.release(token) }
+                    self.ownershipToken = nil
+                }
+            }
+            self.leaveCompletion?.append(completion)
             self.finishJoin(.failure(LocalMediaError("Hotspot join cancelled")))
             if let ssid = self.ssid, self.ownsConfiguration { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
             if !self.applying { self.finishLeave() }
@@ -157,44 +168,77 @@ public final class GlassesHotspotNetwork {
     }
 
     public func awaitInternet(allowWifiAfterRelease: Bool = false, completion: @escaping (Bool, String) -> Void) {
-        queue.async {
-            let monitor = NWPathMonitor()
-            var finished = false
-            let finish: (Bool, String) -> Void = { usable, detail in
-                guard !finished else { return }
-                finished = true
-                monitor.cancel()
+        queue.async { self.startInternetObservation(allowWifiAfterRelease: allowWifiAfterRelease, completion: completion) }
+    }
+
+    /// Called on the owner queue, including directly from completeLeave. A queued
+    /// cancellation therefore cannot overtake observation initialization.
+    private func startInternetObservation(allowWifiAfterRelease: Bool, completion: @escaping (Bool, String) -> Void) {
+        let gen = generation
+        let observation = HotspotInternetObservation(generation: gen, glassesSSID: lastHotspotSSID)
+        let monitor = NWPathMonitor()
+        let sampleTimer = DispatchSource.makeTimerSource(queue: queue)
+        var currentPath: Network.NWPath?
+        let finish: (Bool, String) -> Void = { usable, detail in
+            guard observation.settle() else { return }
+            monitor.pathUpdateHandler = nil
+            monitor.cancel()
+            sampleTimer.setEventHandler {}
+            sampleTimer.cancel()
+            currentPath = nil
+            let reply = {
+                self.internetObservationOwner.clear(observation)
                 completion(usable, detail)
             }
-            monitor.pathUpdateHandler = { path in
-                if let route = HotspotInternetPolicy.route(satisfied: path.status == .satisfied,
-                                                           cellular: path.usesInterfaceType(.cellular),
-                                                           ethernet: path.usesInterfaceType(.wiredEthernet))
-                {
+            // Even a timed-out/cancelled observation joins its dispatched
+            // CoreWLAN read before releasing this session's owner.
+            observation.afterSSIDRead(reply)
+        }
+        internetObservationOwner.install(observation) { finish(false, "Hotspot internet observation cancelled") }
+        var currentPathRevision = 0
+        let sample = {
+            guard let path = currentPath else { return }
+            if let route = HotspotInternetPolicy.route(satisfied: path.status == .satisfied,
+                                                       cellular: path.usesInterfaceType(.cellular),
+                                                       ethernet: path.usesInterfaceType(.wiredEthernet))
+            {
+                finish(true, route)
+                return
+            }
+            // Sample returned membership while the route remains on Wi-Fi;
+            // NWPath need not report a new interface when the SSID changes.
+            guard allowWifiAfterRelease, path.status == .satisfied,
+                  path.usesInterfaceType(.wifi), observation.beginSSIDRead() else { return }
+            let pathRevision = currentPathRevision
+            let observed: (String?) -> Void = { ssid in
+                self.queue.async {
+                    observation.completeSSIDRead()
+                    guard gen == self.generation else { finish(false, "Hotspot session changed"); return }
+                    guard let route = observation.restoredWifiRoute(ssid: ssid, pathRevision: pathRevision, currentGeneration: self.generation)
+                    else { return }
                     finish(true, route)
-                    return
-                }
-                // Once the hotspot is released, a return to the user's Wi-Fi is also valid.
-                // Do not mistake the departing glasses AP's local-only path for restored internet.
-                if allowWifiAfterRelease, path.status == .satisfied, path.usesInterfaceType(.wifi) {
-                    NEHotspotNetwork.fetchCurrent { network in
-                        self.queue.async {
-                            guard let route = HotspotInternetPolicy.route(satisfied: true, cellular: false, ethernet: false,
-                                                                          restoredWifiSSID: network?.ssid, glassesSSID: self.lastHotspotSSID)
-                            else { return }
-                            finish(true, route)
-                        }
-                    }
                 }
             }
-            monitor.start(queue: self.queue)
-            self.queue.asyncAfter(deadline: .now() + 15) {
-                finish(false, allowWifiAfterRelease ? "Internet did not return after leaving the glasses hotspot" : "Cellular or Ethernet internet did not become the default route")
-            }
+            if ProcessInfo.processInfo.isiOSAppOnMac {
+                self.macWorker.async { observed(try? MacHotspotAssociation.observeCurrentSSID()) }
+            } else { NEHotspotNetwork.fetchCurrent { observed($0?.ssid) } }
+        }
+        monitor.pathUpdateHandler = { path in
+            guard let pathRevision = observation.beginPath(currentGeneration: self.generation) else { finish(false, "Hotspot session changed"); return }
+            currentPath = path
+            currentPathRevision = pathRevision
+            sample()
+        }
+        sampleTimer.setEventHandler(handler: sample)
+        sampleTimer.schedule(deadline: .now() + 0.5, repeating: 0.5)
+        sampleTimer.resume()
+        monitor.start(queue: queue)
+        queue.asyncAfter(deadline: .now() + 15) {
+            finish(false, allowWifiAfterRelease ? "Internet did not return after leaving the glasses hotspot" : "Cellular or Ethernet internet did not become the default route")
         }
     }
 
-    private func authorizeMacAssociation(ssid: String, passphrase: String, generation gen: Int) {
+    private func authorizeMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval) {
         let authorization = MacHotspotAuthorization()
         macAuthorization = authorization
         authorization.start { result in
@@ -202,7 +246,7 @@ public final class GlassesHotspotNetwork {
                 guard gen == self.generation, !self.cancelled else { return }
                 self.macAuthorization = nil
                 switch result {
-                case .success: self.applyMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen)
+                case .success: self.applyMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen, deadline: deadline)
                 case let .failure(error):
                     self.finishJoin(.failure(error)); self.finishLeave()
                 }
@@ -210,8 +254,8 @@ public final class GlassesHotspotNetwork {
         }
     }
 
-    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int) {
-        let association = MacHotspotAssociation()
+    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval) {
+        let association = MacHotspotAssociation(deadline: deadline)
         macAssociation = association
         applying = true
         macWorker.async {
@@ -427,9 +471,9 @@ public final class GlassesHotspotNetwork {
                         // 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)) }
+                        let completion = self.leaveCompletion
+                        self.leaveCompletion = nil
+                        completion?.complete(.failure(error))
                     }
                 }
             }
@@ -437,6 +481,7 @@ public final class GlassesHotspotNetwork {
     }
 
     private func completeLeave() {
+        internetObservationOwner.cancel()
         generation += 1
         macAuthorization?.cancel(); macAuthorization = nil
         localAccess?.cancel(); localAccess = nil
@@ -448,12 +493,25 @@ public final class GlassesHotspotNetwork {
         ssid = 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(.success(())) }
+        let finish = {
+            self.waitForInternetAfterLeave = false
+            self.finishingLeave = false
+            let completion = self.leaveCompletion
+            self.leaveCompletion = nil
+            if let completion { completion.complete(.success(())) } else {
+                if let token = self.ownershipToken { HotspotNetworkOwnership.shared.release(token) }
+                self.ownershipToken = nil
+            }
+        }
+        if waitForInternetAfterLeave, ProcessInfo.processInfo.isiOSAppOnMac {
+            // Keep this owner until the default route returns or the existing
+            // bounded observation ends. Route readiness is not HTTP success;
+            // the following ordinary update check still owns that result.
+            startInternetObservation(allowWifiAfterRelease: true) { ready, reason in
+                self.logger.info("HOTSPOT_LEAVE internet_recovery ready=\(ready) reason=\(reason, privacy: .public)")
+                finish()
+            }
+        } else { finish() }
     }
 
     /// Every attached interface's kernel index and link type (its AF_LINK row) and every IPv4

package/ios/GlassesMediaRelayModule.swift

@@ -31,10 +31,10 @@ public final class GlassesMediaRelayModule: Module {
             }
         }
 
-        AsyncFunction("leaveLocalHotspot") { (id: String, promise: Promise) in
+        AsyncFunction("leaveLocalHotspot") { (id: String, waitForInternet: Bool, promise: Promise) in
             self.queue.async {
                 guard self.localHotspotOwner == id else { promise.resolve(nil); return }
-                self.localHotspot.leave { result in
+                self.localHotspot.leave(waitForInternet: waitForInternet) { result in
                     self.queue.async {
                         switch result {
                         case .success:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/glasses-media",
-  "version": "3.4.0-dev.950",
+  "version": "3.4.0-dev.951",
   "description": "Shared native glasses media receivers and local network transport",
   "license": "MIT",
   "author": "Mentra Community",