@mentra/glasses-media 3.4.0-dev.975 → 3.4.0-dev.978

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

@@ -13,28 +13,32 @@ final class MacHotspotAssociation {
     private let now: () -> TimeInterval
     private let pause: ((TimeInterval) -> Void)?
     private let makeInterface: () throws -> MacWifiInterface
+    private let authorization: MacHotspotAuthorization?
 
     init(deadline: TimeInterval = ProcessInfo.processInfo.systemUptime + 60,
          now: @escaping () -> TimeInterval = { ProcessInfo.processInfo.systemUptime },
          pause: ((TimeInterval) -> Void)? = nil,
          makeInterface: (() throws -> MacWifiInterface)? = nil,
-         authorizationFacts: MacHotspotAuthorizationFacts? = nil)
+         authorizationFacts: MacHotspotAuthorizationFacts? = nil,
+         authorization: MacHotspotAuthorization? = nil)
     {
         self.deadline = deadline
         self.now = now
         self.pause = pause
-        self.makeInterface = makeInterface ?? { try PublicCoreWlanInterface(authorizationFacts: authorizationFacts) }
+        self.authorization = authorization
+        self.makeInterface = makeInterface ?? { try PublicCoreWlanInterface(authorizationFacts: authorizationFacts, authorization: authorization) }
     }
 
     func associate(ssid: String, password: String) throws -> String {
         try checkCurrent()
         let interface = try makeInterface()
         self.interface = interface
-        if try interface.currentSSID() != ssid {
+        if try readSSID(interface) != ssid {
             let network = try discoverNetwork(ssid: ssid, interface: interface)
             try checkDiscoveryCurrent()
-            if let network, try interface.currentSSID() != ssid {
+            if let network, try readSSID(interface) != ssid {
                 try checkDiscoveryCurrent()
+                try authorization?.requireCurrentAuthorization()
                 // Record the intended association before this blocking call. A late
                 // successful join still belongs to us and must be cleaned up.
                 joinedSSID = ssid
@@ -42,7 +46,7 @@ final class MacHotspotAssociation {
             }
         }
         try checkCurrent()
-        guard try interface.currentSSID() == ssid else {
+        guard try readSSID(interface) == ssid else {
             throw LocalMediaError("Mac Wi-Fi did not associate with the requested glasses hotspot")
         }
         return try interface.name()
@@ -56,9 +60,9 @@ final class MacHotspotAssociation {
     /// A connection the user replaced must never be disconnected by our cleanup.
     func leave() throws {
         if let joinedSSID {
-            if try interface?.currentSSID() == joinedSSID {
-                interface?.disassociate()
-                guard try interface?.currentSSID() != joinedSSID else {
+            if let interface, try readSSID(interface) == joinedSSID {
+                interface.disassociate()
+                guard try readSSID(interface) != joinedSSID else {
                     throw LocalMediaError("Mac Wi-Fi has not released the glasses hotspot")
                 }
             }
@@ -68,7 +72,15 @@ final class MacHotspotAssociation {
     }
 
     func currentSSID() throws -> String? {
-        try interface?.currentSSID()
+        guard let interface else { return nil }
+        return try readSSID(interface)
+    }
+
+    private func readSSID(_ interface: MacWifiInterface) throws -> String? {
+        try authorization?.requireCurrentAuthorization()
+        let ssid = try interface.currentSSID()
+        try authorization?.requireCurrentAuthorization()
+        return ssid
     }
 
     static func observeCurrentSSID() throws -> String? {
@@ -79,10 +91,11 @@ final class MacHotspotAssociation {
         while true {
             try checkDiscoveryCurrent()
             // Recheck Location authorization before and after each blocking scan.
-            if try interface.currentSSID() == ssid { return nil }
+            if try readSSID(interface) == ssid { return nil }
+            try authorization?.requireCurrentAuthorization()
             let network = try interface.network(ssid: ssid)
             try checkDiscoveryCurrent()
-            if try interface.currentSSID() == ssid { return nil }
+            if try readSSID(interface) == 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.
@@ -131,10 +144,12 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
     private let bundle: Bundle
     private let interface: NSObject
     private let authorizationFacts: MacHotspotAuthorizationFacts
+    private let authorization: MacHotspotAuthorization?
     private typealias Disassociate = @convention(c) (AnyObject, Selector) -> Void
 
-    init(authorizationFacts: MacHotspotAuthorizationFacts? = nil) throws {
+    init(authorizationFacts: MacHotspotAuthorizationFacts? = nil, authorization: MacHotspotAuthorization? = nil) throws {
         self.authorizationFacts = authorizationFacts ?? MacHotspotAuthorizationFacts()
+        self.authorization = authorization
         guard let bundle = Bundle(path: "/System/Library/Frameworks/CoreWLAN.framework") else {
             throw LocalMediaError("Mac Wi-Fi framework is unavailable")
         }
@@ -162,16 +177,24 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
     }
 
     func currentSSID() throws -> String? {
+        try requireAuthorization()
+        guard let data = interface.perform(NSSelectorFromString("ssidData"))?.takeUnretainedValue() as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    private func requireAuthorization() throws {
+        if let authorization { try authorization.requireCurrentAuthorization(); return }
+        // Independent internet-return observation has no owned join recipient.
+        // Its existing static authorization guard remains unchanged.
         let authorization = CLLocationManager.authorizationStatus()
         guard MacHotspotAuthorization.isAuthorized(authorization) else {
             throw authorizationFacts.failure("Location access is required to verify the current Mac Wi-Fi network", raw: authorization.rawValue,
                                              getter: .staticSSID, foreground: MacHotspotAuthorizationFacts.foreground())
         }
-        guard let data = interface.perform(NSSelectorFromString("ssidData"))?.takeUnretainedValue() as? Data else { return nil }
-        return String(data: data, encoding: .utf8)
     }
 
     func network(ssid: String) throws -> NSObject? {
+        try requireAuthorization()
         let selector = NSSelectorFromString("scanForNetworksWithSSID:error:")
         let invoke = unsafeBitCast(interface.method(for: selector), to: MacWifiInvocation.Scan.self)
         var error: NSError?
@@ -190,6 +213,7 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
     }
 
     func associate(network: NSObject, password: String) throws {
+        try requireAuthorization()
         let selector = NSSelectorFromString("associateToNetwork:password:error:")
         let invoke = unsafeBitCast(interface.method(for: selector), to: MacWifiInvocation.Associate.self)
         var error: NSError?

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

@@ -6,19 +6,31 @@ import Foundation
 final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
     private var manager: CLLocationManager?
     private var completion: ((Result<Void, Error>) -> Void)?
-    private var finished = false
+    private var started = false
+    private var closed = false
+    private var ready = false
+    private var revoked = false
     private let facts: MacHotspotAuthorizationFacts
+    private let makeManager: () -> CLLocationManager
+    private let locationServicesEnabled: () -> Bool
+    var onRevoked: ((Error) -> Void)?
+    var onRestored: (() -> Void)?
 
-    init(facts: MacHotspotAuthorizationFacts = MacHotspotAuthorizationFacts()) {
+    init(facts: MacHotspotAuthorizationFacts = MacHotspotAuthorizationFacts(), makeManager: @escaping () -> CLLocationManager = { CLLocationManager() },
+         locationServicesEnabled: @escaping () -> Bool = { CLLocationManager.locationServicesEnabled() })
+    {
         self.facts = facts
+        self.makeManager = makeManager
+        self.locationServicesEnabled = locationServicesEnabled
         super.init()
     }
 
     func start(completion: @escaping (Result<Void, Error>) -> Void) {
         DispatchQueue.main.async {
-            guard !self.finished else { completion(.failure(CancellationError())); return }
+            guard !self.closed, !self.started else { completion(.failure(CancellationError())); return }
+            self.started = true
             self.completion = completion
-            let manager = CLLocationManager()
+            let manager = self.makeManager()
             self.manager = manager
             manager.delegate = self
             self.handle(manager.authorizationStatus, getter: .instanceInitial)
@@ -27,10 +39,48 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
     }
 
     func cancel() {
-        DispatchQueue.main.async { self.finish(.failure(CancellationError())) }
+        DispatchQueue.main.async {
+            self.closed = true
+            self.ready = false
+            self.reply(.failure(CancellationError()))
+            self.manager?.delegate = nil
+            self.manager = nil
+            self.onRevoked = nil
+            self.onRestored = nil
+        }
+    }
+
+    /// A ready session retains its manager through owned Wi-Fi cleanup. An unanswered
+    /// authorization request must still settle when the join is cancelled.
+    func cancelPending() {
+        DispatchQueue.main.async {
+            if self.completion != nil { self.cancel() }
+        }
+    }
+
+    /// Query the same initialized recipient on its owning thread for every native read
+    /// or write. An earlier success is never an authorization cache.
+    func requireCurrentAuthorization() throws {
+        let check = {
+            guard !self.closed, let manager = self.manager else { throw CancellationError() }
+            let status = manager.authorizationStatus
+            let foreground = MacHotspotAuthorizationFacts.foreground()
+            self.facts.observeInstance(raw: status.rawValue, getter: .instanceCurrent, foreground: foreground)
+            guard self.locationServicesEnabled() else {
+                throw self.facts.failure("Location services are required to verify the current Mac Wi-Fi network", raw: status.rawValue,
+                                         getter: .instanceCurrent, foreground: foreground)
+            }
+            guard Self.isAuthorized(status) else {
+                throw self.facts.failure("Location access is required to verify the current Mac Wi-Fi network", raw: status.rawValue,
+                                         getter: .instanceCurrent, foreground: foreground)
+            }
+        }
+        if Thread.isMainThread { try check() }
+        else { try DispatchQueue.main.sync(execute: check) }
     }
 
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        guard manager === self.manager, !closed else { return }
         handle(manager.authorizationStatus, getter: .instanceCallback)
     }
 
@@ -44,22 +94,31 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
 
     private func handle(_ status: CLAuthorizationStatus, getter: MacHotspotAuthorizationFacts.Getter) {
         let foreground = MacHotspotAuthorizationFacts.foreground()
-        if !finished { facts.observeInstance(raw: status.rawValue, getter: getter, foreground: foreground) }
-        if Self.isAuthorized(status) { finish(.success(())); return }
+        guard !closed else { return }
+        facts.observeInstance(raw: status.rawValue, getter: getter, foreground: foreground)
+        if Self.isAuthorized(status) {
+            ready = true
+            if revoked { revoked = false; onRestored?() }
+            reply(.success(()))
+            return
+        }
+        let error = facts.failure("Location access is required to identify the glasses hotspot on Mac", raw: status.rawValue, getter: getter, foreground: foreground)
+        if ready {
+            ready = false
+            revoked = true
+            onRevoked?(error)
+            return
+        }
         switch status {
         case .denied, .restricted:
-            finish(.failure(facts.failure("Location access is required to identify the glasses hotspot on Mac", raw: status.rawValue, getter: getter, foreground: foreground)))
+            reply(.failure(error))
         case .notDetermined: break
         default:
-            finish(.failure(facts.failure("Mac hotspot Location authorization is unavailable", raw: status.rawValue, getter: getter, foreground: foreground)))
+            reply(.failure(facts.failure("Mac hotspot Location authorization is unavailable", raw: status.rawValue, getter: getter, foreground: foreground)))
         }
     }
 
-    private func finish(_ result: Result<Void, Error>) {
-        guard !finished else { return }
-        finished = true
-        manager?.delegate = nil
-        manager = nil
+    private func reply(_ result: Result<Void, Error>) {
         let reply = completion
         completion = nil
         reply?(result)

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

@@ -7,7 +7,7 @@ import Foundation
 
 /// Diagnostic observations only. These facts never authorize a network read or a join.
 final class MacHotspotAuthorizationFacts {
-    enum Getter: String { case instanceInitial = "instance-initial", instanceCallback = "instance-callback", staticSSID = "static-ssid" }
+    enum Getter: String { case instanceInitial = "instance-initial", instanceCallback = "instance-callback", instanceCurrent = "instance-current", staticSSID = "static-ssid" }
     enum Foreground: String { case active, inactive, background, unknown }
     private let lock = NSLock()
     private var instance: (raw: Int32, getter: Getter, foreground: Foreground)?

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

@@ -0,0 +1,35 @@
+import Foundation
+
+/// Retain a real authorization restoration while this session's cleanup result
+/// is still returning from its worker. All state belongs to the hotspot owner queue.
+final class MacHotspotCleanupContinuation {
+    private var restorationPending = false
+    private let isCurrentCancelledSession: () -> Bool
+    private let requestCleanup: () -> Void
+
+    init(authorization: MacHotspotAuthorization, queue: DispatchQueue,
+         isCurrentCancelledSession: @escaping () -> Bool, requestCleanup: @escaping () -> Void)
+    {
+        self.isCurrentCancelledSession = isCurrentCancelledSession
+        self.requestCleanup = requestCleanup
+        authorization.onRestored = { [weak self] in
+            queue.async { [weak self] in
+                guard let self, self.isCurrentCancelledSession() else { return }
+                self.restorationPending = true
+                self.requestCleanup()
+            }
+        }
+    }
+
+    func cleanupStarted() {
+        restorationPending = false
+    }
+
+    func cleanupFailed() {
+        guard restorationPending, isCurrentCancelledSession() else { return }
+        restorationPending = false
+        // A current restoration was not consumed by the failed worker attempt.
+        // Resume only its owned cleanup, which rechecks live permission and SSID.
+        requestCleanup()
+    }
+}

package/ios/GlassesHotspotNetwork.swift

@@ -31,6 +31,7 @@ public final class GlassesHotspotNetwork {
     private let macWorker = DispatchQueue(label: "com.mentra.glassesmedia.mac-wifi")
     private var macAssociation: MacHotspotAssociation?
     private var macAuthorization: MacHotspotAuthorization?
+    private var macCleanupContinuation: MacHotspotCleanupContinuation?
     private var ownershipToken: UUID?
     private var finishingLeave = false
     private var waitForInternetAfterLeave = false
@@ -75,7 +76,7 @@ public final class GlassesHotspotNetwork {
                 guard gen == self.generation, self.joinReply != nil, self.localAccess == nil else { return }
                 self.cancelled = true
                 self.macAssociation?.cancel()
-                self.macAuthorization?.cancel()
+                self.macAuthorization?.cancelPending()
                 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.
@@ -91,7 +92,7 @@ public final class GlassesHotspotNetwork {
             self.waitForInternetAfterLeave = self.waitForInternetAfterLeave || waitForInternet
             self.cancelled = true
             self.macAssociation?.cancel()
-            self.macAuthorization?.cancel()
+            self.macAuthorization?.cancelPending()
             if self.leaveCompletion == nil {
                 self.leaveCompletion = HotspotLeaveCompletion {
                     if let token = self.ownershipToken { HotspotNetworkOwnership.shared.release(token) }
@@ -242,12 +243,30 @@ public final class GlassesHotspotNetwork {
         let facts = MacHotspotAuthorizationFacts()
         let authorization = MacHotspotAuthorization(facts: facts)
         macAuthorization = authorization
+        authorization.onRevoked = { [weak self] error in
+            guard let self else { return }
+            self.queue.async {
+                guard gen == self.generation, !self.cancelled else { return }
+                self.cancelled = true
+                self.macAssociation?.cancel()
+                self.finishJoin(.failure(error))
+                self.onLost?("Glasses hotspot Location authorization was revoked")
+                if !self.applying { self.finishLeave() }
+            }
+        }
+        macCleanupContinuation = MacHotspotCleanupContinuation(authorization: authorization, queue: queue,
+                                                               isCurrentCancelledSession: { [weak self] in
+                                                                   guard let self else { return false }
+                                                                   return gen == self.generation && self.cancelled
+                                                               }, requestCleanup: { [weak self] in
+                                                                   guard let self, !self.applying else { return }
+                                                                   self.finishLeave()
+                                                               })
         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, deadline: deadline, authorizationFacts: facts)
+                case .success: self.applyMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen, deadline: deadline, authorizationFacts: facts, authorization: authorization)
                 case let .failure(error):
                     self.finishJoin(.failure(error)); self.finishLeave()
                 }
@@ -255,8 +274,8 @@ public final class GlassesHotspotNetwork {
         }
     }
 
-    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval, authorizationFacts: MacHotspotAuthorizationFacts) {
-        let association = MacHotspotAssociation(deadline: deadline, authorizationFacts: authorizationFacts)
+    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval, authorizationFacts: MacHotspotAuthorizationFacts, authorization: MacHotspotAuthorization) {
+        let association = MacHotspotAssociation(deadline: deadline, authorizationFacts: authorizationFacts, authorization: authorization)
         macAssociation = association
         applying = true
         macWorker.async {
@@ -457,6 +476,7 @@ public final class GlassesHotspotNetwork {
     private func finishLeave() {
         guard !finishingLeave else { return }
         finishingLeave = true
+        macCleanupContinuation?.cleanupStarted()
         if let association = macAssociation {
             association.cancel()
             // This queue is also the association queue: cleanup cannot overtake
@@ -475,6 +495,7 @@ public final class GlassesHotspotNetwork {
                         let completion = self.leaveCompletion
                         self.leaveCompletion = nil
                         completion?.complete(.failure(error))
+                        self.macCleanupContinuation?.cleanupFailed()
                     }
                 }
             }
@@ -483,6 +504,7 @@ public final class GlassesHotspotNetwork {
 
     private func completeLeave() {
         internetObservationOwner.cancel()
+        macCleanupContinuation = nil
         generation += 1
         macAuthorization?.cancel(); macAuthorization = nil
         localAccess?.cancel(); localAccess = nil

package/package.json

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