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

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

@@ -17,12 +17,13 @@ final class MacHotspotAssociation {
     init(deadline: TimeInterval = ProcessInfo.processInfo.systemUptime + 60,
          now: @escaping () -> TimeInterval = { ProcessInfo.processInfo.systemUptime },
          pause: ((TimeInterval) -> Void)? = nil,
-         makeInterface: @escaping () throws -> MacWifiInterface = { try PublicCoreWlanInterface() })
+         makeInterface: (() throws -> MacWifiInterface)? = nil,
+         authorizationFacts: MacHotspotAuthorizationFacts? = nil)
     {
         self.deadline = deadline
         self.now = now
         self.pause = pause
-        self.makeInterface = makeInterface
+        self.makeInterface = makeInterface ?? { try PublicCoreWlanInterface(authorizationFacts: authorizationFacts) }
     }
 
     func associate(ssid: String, password: String) throws -> String {
@@ -129,9 +130,11 @@ enum MacWifiInvocation {
 private final class PublicCoreWlanInterface: MacWifiInterface {
     private let bundle: Bundle
     private let interface: NSObject
+    private let authorizationFacts: MacHotspotAuthorizationFacts
     private typealias Disassociate = @convention(c) (AnyObject, Selector) -> Void
 
-    init() throws {
+    init(authorizationFacts: MacHotspotAuthorizationFacts? = nil) throws {
+        self.authorizationFacts = authorizationFacts ?? MacHotspotAuthorizationFacts()
         guard let bundle = Bundle(path: "/System/Library/Frameworks/CoreWLAN.framework") else {
             throw LocalMediaError("Mac Wi-Fi framework is unavailable")
         }
@@ -161,7 +164,8 @@ private final class PublicCoreWlanInterface: MacWifiInterface {
     func currentSSID() throws -> String? {
         let authorization = CLLocationManager.authorizationStatus()
         guard MacHotspotAuthorization.isAuthorized(authorization) else {
-            throw LocalMediaError("Location access is required to verify the current Mac Wi-Fi network")
+            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)

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

@@ -7,6 +7,12 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
     private var manager: CLLocationManager?
     private var completion: ((Result<Void, Error>) -> Void)?
     private var finished = false
+    private let facts: MacHotspotAuthorizationFacts
+
+    init(facts: MacHotspotAuthorizationFacts = MacHotspotAuthorizationFacts()) {
+        self.facts = facts
+        super.init()
+    }
 
     func start(completion: @escaping (Result<Void, Error>) -> Void) {
         DispatchQueue.main.async {
@@ -15,7 +21,7 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
             let manager = CLLocationManager()
             self.manager = manager
             manager.delegate = self
-            self.handle(manager.authorizationStatus)
+            self.handle(manager.authorizationStatus, getter: .instanceInitial)
             if manager.authorizationStatus == .notDetermined { manager.requestWhenInUseAuthorization() }
         }
     }
@@ -25,7 +31,7 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
     }
 
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
-        handle(manager.authorizationStatus)
+        handle(manager.authorizationStatus, getter: .instanceCallback)
     }
 
     static func isAuthorized(_ status: CLAuthorizationStatus) -> Bool {
@@ -36,14 +42,16 @@ final class MacHotspotAuthorization: NSObject, CLLocationManagerDelegate {
         return false
     }
 
-    private func handle(_ status: CLAuthorizationStatus) {
+    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 }
         switch status {
         case .denied, .restricted:
-            finish(.failure(LocalMediaError("Location access is required to identify the glasses hotspot on Mac")))
+            finish(.failure(facts.failure("Location access is required to identify the glasses hotspot on Mac", raw: status.rawValue, getter: getter, foreground: foreground)))
         case .notDetermined: break
         default:
-            finish(.failure(LocalMediaError("Mac hotspot Location authorization is unavailable")))
+            finish(.failure(facts.failure("Mac hotspot Location authorization is unavailable", raw: status.rawValue, getter: getter, foreground: foreground)))
         }
     }
 

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

@@ -0,0 +1,51 @@
+import Foundation
+#if canImport(UIKit)
+    import UIKit
+#elseif canImport(AppKit)
+    import AppKit
+#endif
+
+/// 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 Foreground: String { case active, inactive, background, unknown }
+    private let lock = NSLock()
+    private var instance: (raw: Int32, getter: Getter, foreground: Foreground)?
+    private var initialCallbackObserved = false
+    private let pid = ProcessInfo.processInfo.processIdentifier
+    private let bundleID = Bundle.main.bundleIdentifier.flatMap { value in
+        value.range(of: "^[A-Za-z0-9_.-]{1,128}$", options: .regularExpression) == nil ? nil : value
+    } ?? "unknown"
+
+    /// UIKit/AppKit state is sampled only on its owning thread. A worker read stays unknown.
+    static func foreground() -> Foreground {
+        guard Thread.isMainThread else { return .unknown }
+        #if canImport(UIKit)
+            switch UIApplication.shared.applicationState {
+            case .active: return .active
+            case .inactive: return .inactive
+            case .background: return .background
+            @unknown default: return .unknown
+            }
+        #elseif canImport(AppKit)
+            return NSApplication.shared.isActive ? .active : .inactive
+        #else
+            return .unknown
+        #endif
+    }
+
+    func observeInstance(raw: Int32, getter: Getter, foreground: Foreground) {
+        lock.lock(); defer { lock.unlock() }
+        instance = (raw, getter, foreground)
+        if getter == .instanceCallback { initialCallbackObserved = true }
+    }
+
+    /// Only enums and this process's identity cross the existing bounded error bridge.
+    func failure(_ message: String, raw: Int32, getter: Getter, foreground: Foreground) -> LocalMediaError {
+        lock.lock(); defer { lock.unlock() }
+        let instanceRaw = instance.map { String($0.raw) } ?? "unknown"
+        let instanceGetter = instance?.getter.rawValue ?? "unknown"
+        let instanceForeground = instance?.foreground.rawValue ?? "unknown"
+        return LocalMediaError("\(message) [location raw=\(raw) getter=\(getter.rawValue) foreground=\(foreground.rawValue) instanceRaw=\(instanceRaw) instanceGetter=\(instanceGetter) instanceForeground=\(instanceForeground) initialCallbackObserved=\(initialCallbackObserved) pid=\(pid) bundle=\(bundleID)]")
+    }
+}

package/ios/GlassesHotspotNetwork.swift

@@ -239,14 +239,15 @@ public final class GlassesHotspotNetwork {
     }
 
     private func authorizeMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval) {
-        let authorization = MacHotspotAuthorization()
+        let facts = MacHotspotAuthorizationFacts()
+        let authorization = MacHotspotAuthorization(facts: facts)
         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, deadline: deadline)
+                case .success: self.applyMacAssociation(ssid: ssid, passphrase: passphrase, generation: gen, deadline: deadline, authorizationFacts: facts)
                 case let .failure(error):
                     self.finishJoin(.failure(error)); self.finishLeave()
                 }
@@ -254,8 +255,8 @@ public final class GlassesHotspotNetwork {
         }
     }
 
-    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval) {
-        let association = MacHotspotAssociation(deadline: deadline)
+    private func applyMacAssociation(ssid: String, passphrase: String, generation gen: Int, deadline: TimeInterval, authorizationFacts: MacHotspotAuthorizationFacts) {
+        let association = MacHotspotAssociation(deadline: deadline, authorizationFacts: authorizationFacts)
         macAssociation = association
         applying = true
         macWorker.async {

package/package.json

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