@mentra/bluetooth-sdk 3.2.0-dev.200 → 3.2.0-dev.203

package/ios/Source/WifiRequestResolution.swift

@@ -0,0 +1,251 @@
+import CoreFoundation
+import Foundation
+
+private func isWifiProtocolV1(_ raw: Any?) -> Bool {
+    guard let number = raw as? NSNumber,
+          CFGetTypeID(number) != CFBooleanGetTypeID()
+    else { return false }
+    return number.doubleValue == 1
+}
+
+/// Validate raw fields before convenience conversions erase malformed or partial tuples.
+func wifiResponseEnvelopeIsValid(_ values: [String: Any], allowLegacy: Bool) -> Bool {
+    for key in ["connected", "dispatched"] where values[key] != nil {
+        guard let number = values[key] as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID()
+        else { return false }
+    }
+    let hasTuple = ["protocol_version", "requestId", "sid"].contains { values[$0] != nil }
+    if !hasTuple { return allowLegacy && values["outcome"] == nil }
+    guard let requestId = values["requestId"] as? String,
+          let sid = values["sid"] as? String
+    else { return false }
+    return isWifiProtocolV1(values["protocol_version"]) && wifiSsidIsValid(requestId) && wifiSsidIsValid(sid)
+        && values["dispatched"] == nil
+}
+
+func wifiSsidIsValid(_ ssid: String) -> Bool {
+    !ssid.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+}
+
+let wifiCapabilityNegotiationTimeoutCode = "capability_negotiation_timeout"
+
+enum WifiProtocolCapability: Equatable {
+    case unknown
+    case supported(version: Int)
+    case unsupported
+    case legacy
+}
+
+enum WifiRequestMode: Equatable {
+    case discovering
+    case modern
+    case legacy
+    case unsupported
+}
+
+final class WifiSessionCapabilities {
+    private(set) var sessionId = ""
+    private(set) var epoch: UInt64 = 0
+    private(set) var forgetResult: WifiProtocolCapability = .unknown
+    private(set) var savedNetworks: WifiProtocolCapability = .unknown
+
+    func reset(sessionId: String = "") {
+        epoch &+= 1
+        self.sessionId = sessionId
+        forgetResult = .unknown
+        savedNetworks = .unknown
+    }
+
+    func applyVersionInfo1(_ values: [String: Any]) {
+        if let sid = values["sid"] as? String, !sid.isEmpty {
+            sessionId = sid
+        }
+        forgetResult = capability(values["wifiForgetResultVersion"])
+        savedNetworks = capability(values["savedWifiNetworksVersion"])
+    }
+
+    func forgetMode() -> WifiRequestMode {
+        Self.requestMode(forgetResult)
+    }
+
+    func savedNetworksMode() -> WifiRequestMode {
+        Self.requestMode(savedNetworks)
+    }
+
+    private func capability(_ raw: Any?) -> WifiProtocolCapability {
+        guard let raw else { return .legacy }
+        return isWifiProtocolV1(raw) && !sessionId.isEmpty ? .supported(version: 1) : .unsupported
+    }
+
+    private static func requestMode(_ capability: WifiProtocolCapability) -> WifiRequestMode {
+        switch capability {
+        case .unknown: .discovering
+        case .supported: .modern
+        case .legacy: .legacy
+        case .unsupported: .unsupported
+        }
+    }
+}
+
+public enum WifiForgetOutcome: String {
+    case confirmed
+    case dispatched
+    case notFound = "not_found"
+    case unsupported
+    case failed
+    case legacyUnverified = "legacy_unverified"
+}
+
+func normalizeWifiForgetResultEvent(
+    requestId: String,
+    sid: String,
+    ssid: String,
+    protocolVersion: Int,
+    outcome: String,
+    legacyDispatched: Bool?,
+    connected: Bool?,
+    currentSsid: String,
+    localIp: String,
+    error: String?
+) -> [String: Any]? {
+    guard wifiSsidIsValid(ssid) else { return nil }
+    if !requestId.isEmpty, !sid.isEmpty,
+       protocolVersion == 1,
+       let modernOutcome = WifiForgetOutcome(rawValue: outcome),
+       modernOutcome != .legacyUnverified
+    {
+        var body: [String: Any] = [
+            "mode": "modern",
+            "requestId": requestId,
+            "sid": sid,
+            "ssid": ssid,
+            "protocolVersion": protocolVersion,
+            "outcome": modernOutcome.rawValue,
+        ]
+        if let connected { body["connected"] = connected }
+        if !currentSsid.isEmpty { body["currentSsid"] = currentSsid }
+        if !localIp.isEmpty { body["localIp"] = localIp }
+        if let error { body["error"] = error }
+        return body
+    }
+    if requestId.isEmpty, sid.isEmpty, protocolVersion == 0, outcome.isEmpty, let legacyDispatched {
+        var body: [String: Any] = [
+            "mode": "legacy",
+            "ssid": ssid,
+            "dispatched": legacyDispatched,
+        ]
+        if let connected { body["connected"] = connected }
+        if !currentSsid.isEmpty { body["currentSsid"] = currentSsid }
+        if !localIp.isEmpty { body["localIp"] = localIp }
+        if let error { body["error"] = error }
+        return body
+    }
+    return nil
+}
+
+public struct WifiForgetResult {
+    public let ssid: String
+    public let outcome: WifiForgetOutcome
+    public let connected: Bool?
+    public let currentSsid: String?
+    public let localIp: String?
+    public let error: String?
+
+    public var values: [String: Any] {
+        var result: [String: Any] = [
+            "ssid": ssid,
+            "outcome": outcome.rawValue,
+        ]
+        if let connected { result["connected"] = connected }
+        if let currentSsid { result["currentSsid"] = currentSsid }
+        if let localIp { result["localIp"] = localIp }
+        if let error { result["error"] = error }
+        return result
+    }
+}
+
+public enum SavedWifiNetworksOutcome: String {
+    case confirmed
+    case unsupported
+    case failed
+}
+
+public struct SavedWifiNetworksResult {
+    public let outcome: SavedWifiNetworksOutcome
+    public let networks: [String]
+    public let error: String?
+
+    public var values: [String: Any] {
+        var result: [String: Any] = [
+            "outcome": outcome.rawValue,
+            "networks": networks,
+        ]
+        if let error { result["error"] = error }
+        return result
+    }
+}
+
+func parseWifiForgetResult(
+    expectedRequestId: String,
+    expectedSid: String,
+    expectedSsid: String,
+    capabilityVersion: Int,
+    data: [String: Any]
+) -> WifiForgetResult? {
+    guard capabilityVersion == 1, !expectedRequestId.isEmpty, !expectedSid.isEmpty,
+          data["requestId"] as? String == expectedRequestId,
+          data["sid"] as? String == expectedSid,
+          data["ssid"] as? String == expectedSsid,
+          isWifiProtocolV1(data["protocolVersion"]),
+          let rawOutcome = data["outcome"] as? String,
+          let outcome = WifiForgetOutcome(rawValue: rawOutcome),
+          outcome != .legacyUnverified
+    else { return nil }
+    return WifiForgetResult(
+        ssid: expectedSsid,
+        outcome: outcome,
+        connected: data["connected"] as? Bool,
+        currentSsid: data["currentSsid"] as? String,
+        localIp: data["localIp"] as? String,
+        error: (data["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+    )
+}
+
+func parseSavedWifiNetworks(
+    expectedRequestId: String,
+    expectedSid: String,
+    capabilityVersion: Int,
+    data: [String: Any]
+) -> SavedWifiNetworksResult? {
+    guard capabilityVersion == 1, !expectedRequestId.isEmpty, !expectedSid.isEmpty,
+          data["requestId"] as? String == expectedRequestId,
+          data["sid"] as? String == expectedSid,
+          isWifiProtocolV1(data["protocolVersion"]),
+          let rawOutcome = data["outcome"] as? String,
+          let outcome = SavedWifiNetworksOutcome(rawValue: rawOutcome)
+    else { return nil }
+    guard let rawNetworks = data["networks"] as? [String], outcome == .confirmed || rawNetworks.isEmpty else { return nil }
+    var seen = Set<String>()
+    let networks = rawNetworks.filter { network in
+        !network.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            && seen.insert(network).inserted
+    }
+    return SavedWifiNetworksResult(
+        outcome: outcome,
+        networks: networks,
+        error: (data["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+    )
+}
+
+func legacyWifiForgetResult(
+    ssid: String
+) -> WifiForgetResult {
+    return WifiForgetResult(
+        ssid: ssid,
+        outcome: .legacyUnverified,
+        connected: nil,
+        currentSsid: nil,
+        localIp: nil,
+        error: nil
+    )
+}

package/ios/Source/sgcs/MentraLive.swift

@@ -2796,7 +2796,11 @@ class MentraLive: NSObject, SGCManager {
             // Record the session id BEFORE marking ready: an unsolicited glasses_ready
             // already runs this full remote-reset flow, so recording (not re-triggering)
             // is correct here; version_info detection covers the restart case.
-            if let sid = json["sid"] as? String, !sid.isEmpty { glassesSessionId = sid }
+            glassesSessionId = (json["sid"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            Bridge.sendTypedMessage(
+                "wifi_protocol_session_ready",
+                body: ["sid": glassesSessionId ?? ""]
+            )
             readinessCompletedThisBleSession = true
             handleGlassesReady()
 
@@ -2834,6 +2838,33 @@ class MentraLive: NSObject, SGCManager {
             }
             updateWifiStatus(connected: connected, ssid: ssid, ip: ip, error: wifiError.isEmpty ? nil : wifiError)
 
+        case "wifi_forget_result":
+            guard wifiResponseEnvelopeIsValid(json, allowLegacy: true) else { return }
+            Bridge.sendWifiForgetResult(
+                requestId: json["requestId"] as? String ?? "",
+                sid: json["sid"] as? String ?? "",
+                ssid: json["ssid"] as? String ?? "",
+                protocolVersion: (json["protocol_version"] as? NSNumber)?.intValue ?? 0,
+                outcome: json["outcome"] as? String ?? "",
+                legacyDispatched: json["dispatched"] as? Bool,
+                connected: json["connected"] as? Bool,
+                currentSsid: json["current_ssid"] as? String ?? "",
+                localIp: json["local_ip"] as? String ?? "",
+                error: (json["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            )
+
+        case "saved_wifi_networks":
+            guard wifiResponseEnvelopeIsValid(json, allowLegacy: false) else { return }
+            guard let networks = json["networks"] as? [String] else { return }
+            Bridge.sendSavedWifiNetworks(
+                requestId: json["requestId"] as? String ?? "",
+                sid: json["sid"] as? String ?? "",
+                protocolVersion: (json["protocol_version"] as? NSNumber)?.intValue ?? 0,
+                outcome: json["outcome"] as? String ?? "",
+                networks: networks,
+                error: (json["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            )
+
         case "hotspot_status_update":
             let enabled = json["hotspot_enabled"] as? Bool ?? false
             let ssid = json["hotspot_ssid"] as? String ?? ""
@@ -2942,7 +2973,7 @@ class MentraLive: NSObject, SGCManager {
             Bridge.log("LIVE: Received pong response - connection healthy")
 
         case "entering_pairing_mode":
-            let windowMs = max(5_000, min(180_000, json["window_ms"] as? Int ?? 120_000))
+            let windowMs = max(5000, min(180_000, json["window_ms"] as? Int ?? 120_000))
             Bridge.log("LIVE: Glasses entering pairing mode — yield \(windowMs)ms (no forget)")
             enterPairingYield(windowMs: windowMs)
             let body: [String: Any] = [
@@ -3086,6 +3117,7 @@ class MentraLive: NSObject, SGCManager {
 
                 // Extract all fields from JSON (except "type")
                 var fields: [String: Any] = [:]
+                fields["version_info_type"] = type
                 for (key, value) in json {
                     if key != "type" {
                         fields[key] = value
@@ -3647,19 +3679,67 @@ class MentraLive: NSObject, SGCManager {
     }
 
     func forgetWifiNetwork(_ ssid: String) {
-        Bridge.log("LIVE: 📶 Sending WiFi forget command for SSID: \(ssid)")
+        forgetWifiNetwork(ssid, requestId: nil, sid: nil)
+    }
 
-        guard !ssid.isEmpty else {
-            Bridge.log("LIVE: Cannot forget WiFi network - SSID is empty")
-            return
+    @discardableResult func forgetWifiNetwork(_ ssid: String, requestId: String?, sid: String?) -> Bool {
+        guard let peripheral = connectedPeripheral, peripheral.state == .connected, txCharacteristic != nil,
+              (requestId == nil) == (sid == nil)
+        else { return false }
+        if let requestId, let sid, requestId.isEmpty || sid.isEmpty { return false }
+        transportLog("LIVE: 📶 Sending WiFi forget command for SSID: \(ssid)", bridgeLogging: false)
+
+        guard !ssid.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            transportLog("LIVE: Cannot forget WiFi network - SSID is empty", bridgeLogging: false)
+            if let requestId {
+                Bridge.sendWifiForgetResult(
+                    requestId: requestId,
+                    sid: sid ?? "",
+                    ssid: ssid,
+                    protocolVersion: 1,
+                    outcome: "failed",
+                    legacyDispatched: nil,
+                    connected: nil,
+                    currentSsid: "",
+                    localIp: "",
+                    error: "invalid_ssid"
+                )
+            }
+            return false
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "forget_wifi",
             "ssid": ssid,
         ]
+        if let requestId, !requestId.isEmpty {
+            json["requestId"] = requestId
+        }
+        if let sid, !sid.isEmpty {
+            json["sid"] = sid
+            json["protocolVersion"] = 1
+        }
 
-        sendJson(json, wakeUp: true)
+        // The coordinator dispatches while isolated on MainActor. Keep this path native-only so a
+        // public log delegate cannot synchronously reset the session before the payload is queued.
+        return sendJson(json, wakeUp: true, requireAck: true, bridgeLogging: false)
+    }
+
+    @discardableResult func requestSavedWifiNetworks(requestId: String, sid: String) -> Bool {
+        guard let peripheral = connectedPeripheral, peripheral.state == .connected, txCharacteristic != nil,
+              !requestId.isEmpty, !sid.isEmpty
+        else { return false }
+        var command: [String: Any] = ["type": "request_saved_wifi_networks", "requestId": requestId]
+        command["protocolVersion"] = 1
+        if !sid.isEmpty {
+            command["sid"] = sid
+        }
+        return sendJson(
+            command,
+            wakeUp: true,
+            requireAck: true,
+            bridgeLogging: false
+        )
     }
 
     func queryGalleryStatus() {
@@ -4822,20 +4902,31 @@ class MentraLive: NSObject, SGCManager {
         wireBytes: Int,
         packetCount: Int,
         protocolVersion: Int,
-        direction: String
+        direction: String,
+        bridgeLogging: Bool = true
     ) {
-        Bridge.log(
-            "BLE_TRACE direction=\(direction) proto=v\(protocolVersion) payload=\(payloadBytes) wire=\(wireBytes) packets=\(packetCount)"
+        transportLog(
+            "BLE_TRACE direction=\(direction) proto=v\(protocolVersion) payload=\(payloadBytes) wire=\(wireBytes) packets=\(packetCount)",
+            bridgeLogging: bridgeLogging
         )
     }
 
-    private func sendJsonBinary(
+    private func transportLog(_ message: String, bridgeLogging: Bool) {
+        if bridgeLogging {
+            Bridge.log(message)
+        } else {
+            NSLog("%@", message)
+        }
+    }
+
+    @discardableResult private func sendJsonBinary(
         jsonString: String,
         messageId: Int64,
         trackingId: String,
         wakeUp: Bool,
-        requireAck: Bool
-    ) {
+        requireAck: Bool,
+        bridgeLogging: Bool
+    ) -> Bool {
         let payload = Data(jsonString.utf8)
         let msgId = UInt16(truncatingIfNeeded: messageId)
         let fragments = MessageChunker.createBinaryFragments(
@@ -4845,8 +4936,8 @@ class MentraLive: NSObject, SGCManager {
             ackRequested: requireAck && messageId >= 0
         )
         guard !fragments.isEmpty else {
-            Bridge.log("LIVE: Failed to create binary wire fragments")
-            return
+            transportLog("LIVE: Failed to create binary wire fragments", bridgeLogging: bridgeLogging)
+            return false
         }
 
         var totalWireBytes = 0
@@ -4858,7 +4949,7 @@ class MentraLive: NSObject, SGCManager {
                 fragCount: fragment.fragCount,
                 payload: fragment.payload
             ) else {
-                continue
+                return false
             }
             totalWireBytes += packed.count
             let isFinalChunk = index == fragments.count - 1
@@ -4875,12 +4966,30 @@ class MentraLive: NSObject, SGCManager {
             wireBytes: totalWireBytes,
             packetCount: fragments.count,
             protocolVersion: BleWireProtocol.protocolV2,
-            direction: "phone_to_glasses"
+            direction: "phone_to_glasses",
+            bridgeLogging: bridgeLogging
+        )
+        transportLog(
+            "LIVE: Binary v2 queued \(fragments.count) fragments, wireBytes=\(totalWireBytes)",
+            bridgeLogging: bridgeLogging
         )
-        Bridge.log("LIVE: Binary v2 queued \(fragments.count) fragments, wireBytes=\(totalWireBytes)")
+        return true
     }
 
-    func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool = false, requireAck: Bool = true) {
+    func sendJson(
+        _ jsonOriginal: [String: Any],
+        wakeUp: Bool = false,
+        requireAck: Bool = true
+    ) {
+        sendJson(jsonOriginal, wakeUp: wakeUp, requireAck: requireAck, bridgeLogging: true)
+    }
+
+    @discardableResult private func sendJson(
+        _ jsonOriginal: [String: Any],
+        wakeUp: Bool,
+        requireAck: Bool,
+        bridgeLogging: Bool
+    ) -> Bool {
         do {
             var json = jsonOriginal
             var messageId: Int64 = -1
@@ -4904,14 +5013,14 @@ class MentraLive: NSObject, SGCManager {
                 )
 
                 if useBinaryWireProtocol, isNewVersion {
-                    sendJsonBinary(
+                    return sendJsonBinary(
                         jsonString: jsonString,
                         messageId: messageId,
                         trackingId: trackingId,
                         wakeUp: wakeUp,
-                        requireAck: requireAck
+                        requireAck: requireAck,
+                        bridgeLogging: bridgeLogging
                     )
-                    return
                 }
 
                 // First check if the message needs chunking
@@ -4925,17 +5034,20 @@ class MentraLive: NSObject, SGCManager {
 
                 // Check if chunking is needed
                 if MessageChunker.needsChunking(testWrappedJson) {
-                    Bridge.log("LIVE: Message exceeds threshold, chunking required")
+                    transportLog("LIVE: Message exceeds threshold, chunking required", bridgeLogging: bridgeLogging)
 
                     // Create chunks
                     let chunks = MessageChunker.createChunks(
                         originalJson: jsonString, messageId: messageId, wakeUp: wakeUp
                     )
                     guard !chunks.isEmpty else {
-                        Bridge.log("LIVE: Failed to create BLE chunks within K900 packet limit")
-                        return
+                        transportLog(
+                            "LIVE: Failed to create BLE chunks within K900 packet limit",
+                            bridgeLogging: bridgeLogging
+                        )
+                        return false
                     }
-                    Bridge.log("LIVE: Sending \(chunks.count) chunks")
+                    transportLog("LIVE: Sending \(chunks.count) chunks", bridgeLogging: bridgeLogging)
 
                     // Send each chunk
                     for (index, chunk) in chunks.enumerated() {
@@ -4943,7 +5055,11 @@ class MentraLive: NSObject, SGCManager {
                         if let chunkStr = String(data: chunkData, encoding: .utf8) {
                             // Pack each chunk using the normal K900 protocol
                             let packedData =
-                                packJson(chunkStr, wakeUp: wakeUp && index == 0) ?? Data() // Only wakeup on first chunk
+                                packJson(
+                                    chunkStr,
+                                    wakeUp: wakeUp && index == 0,
+                                    bridgeLogging: bridgeLogging
+                                ) ?? Data() // Only wakeup on first chunk
 
                             // Queue the chunk for sending
                             // Only track ACK for the final chunk (which has the mId)
@@ -4964,6 +5080,7 @@ class MentraLive: NSObject, SGCManager {
                                 "chunkJsonBytes": chunkStr.data(using: .utf8)?.count,
                                 "messageBytes": jsonData.count,
                             ])
+                            guard !packedData.isEmpty else { return false }
                             queueSend(packedData, id: chunkTrackingId, trace: trace)
 
                             // Add small delay between chunks to avoid overwhelming the connection
@@ -4973,14 +5090,22 @@ class MentraLive: NSObject, SGCManager {
                         }
                     }
 
-                    Bridge.log("LIVE: All chunks queued for transmission")
+                    transportLog("LIVE: All chunks queued for transmission", bridgeLogging: bridgeLogging)
                 } else {
                     // Normal single message transmission
                     if (json["type"] as? String) == "take_photo" {
-                        Bridge.log("LIVE: PHOTO PIPELINE BLE handoff — sendJson -> queueSend take_photo")
+                        transportLog(
+                            "LIVE: PHOTO PIPELINE BLE handoff — sendJson -> queueSend take_photo",
+                            bridgeLogging: bridgeLogging
+                        )
                     }
-                    Bridge.log("LIVE: Sending data to glasses: \(jsonString)")
-                    let packedData = packJson(jsonString, wakeUp: wakeUp) ?? Data()
+                    transportLog("LIVE: Sending data to glasses: \(jsonString)", bridgeLogging: bridgeLogging)
+                    let packedData =
+                        packJson(
+                            jsonString,
+                            wakeUp: wakeUp,
+                            bridgeLogging: bridgeLogging
+                        ) ?? Data()
                     let trace = createBleWriteTrace(
                         commandInfo: commandInfo,
                         chunkId: nil,
@@ -4994,12 +5119,15 @@ class MentraLive: NSObject, SGCManager {
                     logBleChunkTrace("created", trace, extra: [
                         "messageBytes": jsonData.count,
                     ])
+                    guard !packedData.isEmpty else { return false }
                     queueSend(packedData, id: trackingId, trace: trace)
                 }
+                return true
             }
         } catch {
-            Bridge.log("LIVE: Error creating JSON: \(error)")
+            transportLog("LIVE: Error creating JSON: \(error)", bridgeLogging: bridgeLogging)
         }
+        return false
     }
 
     // MARK: - Status Requests
@@ -5990,7 +6118,11 @@ extension MentraLive {
      * 1. Wrap with C-field: {"C": jsonData}
      * 2. Then pack with BES2700 protocol using little-endian: ## + type + length + {"C": jsonData} + $$
      */
-    private func packJson(_ jsonData: String?, wakeUp: Bool = false) -> Data? {
+    private func packJson(
+        _ jsonData: String?,
+        wakeUp: Bool = false,
+        bridgeLogging: Bool = true
+    ) -> Data? {
         guard let jsonData else { return nil }
 
         do {
@@ -6013,7 +6145,10 @@ extension MentraLive {
             )
 
         } catch {
-            Bridge.log("Error creating JSON wrapper for K900: \(error)")
+            transportLog(
+                "Error creating JSON wrapper for K900: \(error)",
+                bridgeLogging: bridgeLogging
+            )
             return nil
         }
     }

package/ios/Source/sgcs/SGCManager.swift

@@ -195,8 +195,10 @@ protocol SGCManager {
     // MARK: - Network Management
 
     func requestWifiScan(scanId: String?)
+    @discardableResult func requestSavedWifiNetworks(requestId: String, sid: String) -> Bool
     func sendWifiCredentials(_ ssid: String, _ password: String)
     func forgetWifiNetwork(_ ssid: String)
+    @discardableResult func forgetWifiNetwork(_ ssid: String, requestId: String?, sid: String?) -> Bool
     func sendHotspotState(_ enabled: Bool)
     func sendWifiAdbState(_ enabled: Bool)
     func sendOtaStart(otaVersionUrl: String?)
@@ -232,7 +234,17 @@ protocol SGCManager {
 /// doesn't seem to work for concurrency reasons :(
 /// we can make read-only getters for convienence though:
 extension SGCManager {
-    var isMicSuspendedForAudio: Bool { false }
+    var isMicSuspendedForAudio: Bool {
+        false
+    }
+
+    @discardableResult func requestSavedWifiNetworks(requestId _: String, sid _: String) -> Bool {
+        false
+    }
+
+    @discardableResult func forgetWifiNetwork(_: String, requestId _: String?, sid _: String?) -> Bool {
+        false
+    }
 
     /// Default: no-op. Only G2 renders positioned text containers; other glasses ignore it.
     func sendPositionedText(