@mentra/glasses-media 3.2.0-dev.225

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

@@ -0,0 +1,104 @@
+import Foundation
+
+public enum SourceKind: String, Sendable {
+    case whep
+    case direct
+    case softap
+}
+
+public enum SourceState: String, Sendable {
+    case idle
+    case connecting
+    case live
+    case failed
+}
+
+public struct SourceConfig: Equatable, Sendable {
+    public var url: String
+    public var kind: SourceKind
+    public var bindAddress: String?
+
+    public init(url: String, kind: SourceKind = .whep, bindAddress: String? = nil) {
+        self.url = url
+        self.kind = kind
+        self.bindAddress = bindAddress
+    }
+}
+
+public protocol GlassesMediaSource: AnyObject {
+    var state: SourceState { get }
+    var ingestUrl: String? { get }
+    func forceRestart()
+    func start(config: SourceConfig)
+    func restart(config: SourceConfig)
+    func stop()
+    func setPcmDeliveryEnabled(_ enabled: Bool)
+}
+
+public final class GlassesMediaController {
+    private let factory: () -> GlassesMediaSource
+    private var source: GlassesMediaSource?
+
+    public init(factory: @escaping () -> GlassesMediaSource) {
+        self.factory = factory
+    }
+
+    public var state: SourceState {
+        source?.state ?? .idle
+    }
+
+    public func attach(config: SourceConfig) {
+        source?.stop()
+        let next = factory()
+        source = next
+        next.start(config: config)
+    }
+
+    public func restart(config: SourceConfig) {
+        source?.restart(config: config)
+    }
+
+    public func stop() {
+        source?.stop()
+        source = nil
+    }
+
+    public func setPcmDeliveryEnabled(_ enabled: Bool) {
+        source?.setPcmDeliveryEnabled(enabled)
+    }
+}
+
+public extension GlassesMediaSource {
+    var ingestUrl: String? {
+        nil
+    }
+
+    func forceRestart() {}
+}
+
+public extension SourceConfig {
+    /// Validate the host bridge before creating a peer or claiming resources. Preserve the
+    /// legacy WHEP field while requiring an explicit bound address for local reception.
+    static func fromBridge(_ source: [String: Any]?, legacyWhepUrl: String?) throws -> SourceConfig {
+        func nonempty(_ value: Any?) -> String? {
+            guard let value = value as? String else { return nil }
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            return trimmed.isEmpty ? nil : trimmed
+        }
+        guard let source else {
+            guard let url = nonempty(legacyWhepUrl) else { throw LocalMediaError("whepUrl is required") }
+            return SourceConfig(url: url)
+        }
+        switch nonempty(source["type"])?.lowercased() {
+        case "whep":
+            guard let url = nonempty(source["url"]) ?? nonempty(legacyWhepUrl) else { throw LocalMediaError("videoSource.url is required") }
+            return SourceConfig(url: url)
+        case "softap":
+            guard let address = nonempty(source["bindAddress"]), LocalMediaPolicy.isPrivate(address) else {
+                throw LocalMediaError("videoSource.bindAddress must be the phone's hotspot IPv4 address")
+            }
+            return SourceConfig(url: "", kind: .softap, bindAddress: address)
+        default: throw LocalMediaError("Unsupported videoSource.type")
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+import Foundation
+
+public struct LocalMediaError: LocalizedError {
+    public let message: String
+    public init(_ message: String) {
+        self.message = message
+    }
+
+    public var errorDescription: String? {
+        message
+    }
+}
+
+/// The glasses' DHCP server uses a /24. Never substitute an unrelated private interface.
+public enum LocalMediaPolicy {
+    public static func ipv4(_ value: String) -> [UInt8]? {
+        let parts = value.split(separator: ".", omittingEmptySubsequences: false)
+        guard parts.count == 4 else { return nil }
+        let bytes = parts.compactMap { UInt8($0) }
+        return bytes.count == 4 ? bytes : nil
+    }
+
+    public static func sameSubnet(_ lhs: String, _ rhs: String) -> Bool {
+        guard let a = ipv4(lhs), let b = ipv4(rhs) else { return false }
+        return a.prefix(3) == b.prefix(3)
+    }
+
+    public static func isPrivate(_ address: String) -> Bool {
+        guard let bytes = ipv4(address) else { return false }
+        return bytes[0] == 10 || (bytes[0] == 172 && (16 ... 31).contains(bytes[1])) ||
+            (bytes[0] == 192 && bytes[1] == 168)
+    }
+
+    /// Keep only concrete host candidates on the local link. Never rewrite a cellular socket's
+    /// advertised address: a candidate must already belong to the interface it claims.
+    public static func localSdp(_ sdp: String, address: String, answer: Bool) throws -> String {
+        guard isPrivate(address) else { throw LocalMediaError("Invalid hotspot address") }
+        var candidates = 0
+        let lines = sdp.components(separatedBy: .newlines).filter { !$0.isEmpty }.filter { line in
+            guard line.hasPrefix("a=candidate:") else { return true }
+            let fields = line.split(separator: " ")
+            guard fields.count >= 8, fields[2].lowercased() == "udp", fields[6] == "typ", fields[7] == "host" else { return false }
+            let host = String(fields[4])
+            guard answer ? host == address : sameSubnet(host, address) else { return false }
+            candidates += 1
+            return true
+        }
+        guard candidates > 0 else { throw LocalMediaError("No host ICE candidate on the glasses hotspot") }
+        return lines.joined(separator: "\r\n") + "\r\n"
+    }
+}

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

@@ -0,0 +1,145 @@
+import Foundation
+import Network
+
+/// One local publisher, bounded requests, and no HTTP/media work on the UI thread.
+/// The consumer owns negotiation; this server never imports WebRTC or a publisher SDK.
+public final class WhipIngestServer {
+    public typealias Negotiator = (String, @escaping (Result<String, Error>) -> Void) -> Void
+    private let queue = DispatchQueue(label: "com.mentra.glassesmedia.whip.http")
+    private let negotiate: Negotiator
+    private let terminate: () -> Void
+    private let publisherFailed: () -> Bool
+    private var listener: NWListener?
+    private var connections: [UUID: NWConnection] = [:]
+    private var session: String?
+    private var endpoint = ""
+    private var generation = 0
+    private var ready: ((Result<String, Error>) -> Void)?
+
+    public init(negotiate: @escaping Negotiator, terminate: @escaping () -> Void, publisherFailed: @escaping () -> Bool) {
+        self.negotiate = negotiate
+        self.terminate = terminate
+        self.publisherFailed = publisherFailed
+    }
+
+    public func start(address: String, wifiOnly: Bool = true, completion: @escaping (Result<String, Error>) -> Void) {
+        queue.async {
+            guard self.listener == nil else { completion(.failure(LocalMediaError("Listener already started"))); return }
+            do {
+                let parameters = NWParameters.tcp
+                if wifiOnly { parameters.requiredInterfaceType = .wifi }
+                parameters.requiredLocalEndpoint = .hostPort(host: NWEndpoint.Host(address), port: .any)
+                let listener = try NWListener(using: parameters)
+                self.generation += 1
+                let gen = self.generation
+                self.listener = listener
+                self.ready = completion
+                listener.stateUpdateHandler = { [weak self] state in
+                    guard let self, gen == self.generation else { return }
+                    switch state {
+                    case .ready:
+                        guard let port = listener.port else { return }
+                        self.endpoint = "http://\(address):\(port.rawValue)/whip"
+                        self.finishReady(.success(self.endpoint))
+                    case let .failed(error):
+                        self.finishReady(.failure(error))
+                        self.stopLocked()
+                    default: break
+                    }
+                }
+                listener.newConnectionHandler = { [weak self] connection in self?.accept(connection, generation: gen) }
+                listener.start(queue: self.queue)
+                self.queue.asyncAfter(deadline: .now() + 10) { [weak self] in
+                    guard let self, gen == self.generation, self.ready != nil else { return }
+                    self.finishReady(.failure(LocalMediaError("Local listener startup timed out")))
+                    self.stopLocked()
+                }
+            } catch { completion(.failure(error)) }
+        }
+    }
+
+    /// Completion is a barrier: no pending offer can install a peer after this point.
+    public func stop(completion: @escaping () -> Void = {}) {
+        queue.async { self.stopLocked(); completion() }
+    }
+
+    private func finishReady(_ result: Result<String, Error>) {
+        let callback = ready
+        ready = nil
+        callback?(result)
+    }
+
+    private func stopLocked() {
+        generation += 1
+        finishReady(.failure(LocalMediaError("Listener cancelled")))
+        listener?.stateUpdateHandler = nil
+        listener?.newConnectionHandler = nil
+        listener?.cancel()
+        listener = nil
+        session = nil
+        endpoint = ""
+        for id in Array(connections.keys) {
+            reply(id, status: 410)
+        }
+        terminate()
+    }
+
+    private func accept(_ connection: NWConnection, generation gen: Int) {
+        guard gen == generation, listener != nil, connections.count < 4 else { connection.cancel(); return }
+        let id = UUID()
+        connections[id] = connection
+        connection.start(queue: queue)
+        queue.asyncAfter(deadline: .now() + 12) { [weak self] in self?.reply(id, status: 408) }
+        receive(id, data: Data(), generation: gen)
+    }
+
+    private func receive(_ id: UUID, data: Data, generation gen: Int) {
+        guard let connection = connections[id] else { return }
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 16384) { [weak self] bytes, _, complete, error in
+            guard let self, gen == self.generation, self.connections[id] != nil else { return }
+            var data = data
+            if let bytes { data.append(bytes) }
+            do {
+                if let request = try WhipRequest.parse(data) {
+                    self.handle(id, request: request, generation: gen)
+                } else if complete || error != nil {
+                    self.reply(id, status: 400)
+                } else { self.receive(id, data: data, generation: gen) }
+            } catch { self.reply(id, status: 400, body: error.localizedDescription) }
+        }
+    }
+
+    private func handle(_ id: UUID, request: WhipRequest, generation gen: Int) {
+        if request.path == "/whip" || request.path == "/whip/" {
+            guard request.method == "POST" else { reply(id, status: 405, headers: ["Allow": "POST"]); return }
+            guard request.contentType == "application/sdp" else { reply(id, status: 415); return }
+            guard !request.body.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { reply(id, status: 400); return }
+            if session != nil, publisherFailed() { session = nil; terminate() }
+            guard session == nil else { reply(id, status: 409); return }
+            let next = UUID().uuidString
+            session = next
+            negotiate(request.body) { [weak self] result in
+                self?.queue.async {
+                    guard let self, gen == self.generation, self.session == next else { return }
+                    switch result {
+                    case let .success(answer):
+                        self.reply(id, status: 201, body: answer, headers: ["Content-Type": "application/sdp", "Location": "\(self.endpoint)/\(next)"])
+                    case let .failure(error):
+                        self.session = nil
+                        self.reply(id, status: 500, body: error.localizedDescription)
+                    }
+                }
+            }
+        } else if let session, request.path == "/whip/\(session)" {
+            guard request.method == "DELETE" else { reply(id, status: 405, headers: ["Allow": "DELETE"]); return }
+            self.session = nil
+            terminate()
+            reply(id, status: 204)
+        } else { reply(id, status: 404) }
+    }
+
+    private func reply(_ id: UUID, status: Int, body: String = "", headers: [String: String] = [:]) {
+        guard let connection = connections.removeValue(forKey: id) else { return }
+        connection.send(content: WhipRequest.response(status, body: body, headers: headers), completion: .contentProcessed { _ in connection.cancel() })
+    }
+}

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

@@ -0,0 +1,59 @@
+import Foundation
+
+public struct WhipRequest {
+    public let method: String
+    public let path: String
+    public let body: String
+    public let contentType: String
+
+    public static let maxHeaderBytes = 8192
+    public static let maxBodyBytes = 256 * 1024
+
+    /// nil means more bytes are needed. Reject ambiguous framing before reading the body.
+    public static func parse(_ data: Data) throws -> WhipRequest? {
+        guard let boundary = data.range(of: Data("\r\n\r\n".utf8)) else {
+            guard data.count <= maxHeaderBytes else { throw LocalMediaError("HTTP headers too large") }
+            return nil
+        }
+        guard boundary.lowerBound <= maxHeaderBytes,
+              let head = String(data: data[..<boundary.lowerBound], encoding: .utf8)
+        else {
+            throw LocalMediaError("Invalid HTTP headers")
+        }
+        let lines = head.components(separatedBy: "\r\n")
+        let first = lines[0].split(separator: " ")
+        guard first.count == 3, first[2] == "HTTP/1.1", first[1].hasPrefix("/") else {
+            throw LocalMediaError("Invalid HTTP request")
+        }
+        var headers: [String: String] = [:]
+        for line in lines.dropFirst() {
+            guard let colon = line.firstIndex(of: ":") else { throw LocalMediaError("Invalid HTTP header") }
+            let name = line[..<colon].lowercased()
+            guard headers[name] == nil else { throw LocalMediaError("Duplicate HTTP header") }
+            headers[name] = line[line.index(after: colon)...].trimmingCharacters(in: .whitespaces)
+        }
+        guard headers["transfer-encoding"] == nil else { throw LocalMediaError("Chunked offers are unsupported") }
+        let method = String(first[0])
+        guard method != "POST" || headers["content-length"] != nil else { throw LocalMediaError("Content-Length required") }
+        guard let length = Int(headers["content-length"] ?? "0"), length >= 0, length <= maxBodyBytes else {
+            throw LocalMediaError("Invalid or oversized HTTP body")
+        }
+        let end = boundary.upperBound + length
+        guard data.count >= end else { return nil }
+        guard data.count == end, let body = String(data: data[boundary.upperBound ..< end], encoding: .utf8) else {
+            throw LocalMediaError("Invalid HTTP body")
+        }
+        return WhipRequest(method: method, path: String(first[1].split(separator: "?", maxSplits: 1)[0]), body: body,
+                           contentType: (headers["content-type"] ?? "").split(separator: ";").first.map(String.init)?.lowercased() ?? "")
+    }
+
+    public static func response(_ status: Int, body: String = "", headers: [String: String] = [:]) -> Data {
+        let reasons = [201: "Created", 204: "No Content", 400: "Bad Request", 404: "Not Found", 405: "Method Not Allowed", 408: "Request Timeout", 409: "Conflict", 410: "Gone", 415: "Unsupported Media Type", 500: "Internal Server Error", 503: "Service Unavailable"]
+        var value = "HTTP/1.1 \(status) \(reasons[status] ?? "Error")\r\n"
+        for (name, content) in headers {
+            value += "\(name): \(content)\r\n"
+        }
+        value += "Content-Length: \(body.utf8.count)\r\nConnection: close\r\n\r\n\(body)"
+        return Data(value.utf8)
+    }
+}

package/ios/DecodedGlassesMediaSource.swift

@@ -0,0 +1,9 @@
+import CoreVideo
+import Foundation
+
+/// Publishers consume native buffers. No bridge serialization or dependency on ACS.
+public protocol DecodedGlassesMediaSource: GlassesMediaSource {
+    var onFrame: ((CVPixelBuffer) -> Void)? { get set }
+    var onPcm: ((Data, Int, Int) -> Void)? { get set }
+    var onStateChange: ((SourceState, String) -> Void)? { get set }
+}

package/ios/DecodedPcm.swift

@@ -0,0 +1,33 @@
+import AVFoundation
+import Foundation
+
+enum DecodedPcm {
+    static func pcm16(_ buffer: AVAudioPCMBuffer) -> Data? {
+        let channels = Int(buffer.format.channelCount)
+        let frames = Int(buffer.frameLength)
+        guard frames > 0, channels > 0 else { return nil }
+        let interleaved = buffer.format.isInterleaved
+        var data = Data(count: frames * channels * 2)
+        if let source = buffer.int16ChannelData {
+            data.withUnsafeMutableBytes { raw in
+                let output = raw.bindMemory(to: Int16.self)
+                for frame in 0 ..< frames {
+                    for channel in 0 ..< channels {
+                        output[frame * channels + channel] = interleaved ? source[0][frame * channels + channel] : source[channel][frame]
+                    }
+                }
+            }
+        } else if let source = buffer.floatChannelData {
+            data.withUnsafeMutableBytes { raw in
+                let output = raw.bindMemory(to: Int16.self)
+                for frame in 0 ..< frames {
+                    for channel in 0 ..< channels {
+                        let sample = interleaved ? source[0][frame * channels + channel] : source[channel][frame]
+                        output[frame * channels + channel] = Int16(max(-1, min(1, sample.isFinite ? sample : 0)) * Float(Int16.max))
+                    }
+                }
+            }
+        } else { return nil }
+        return data
+    }
+}

package/ios/GlassesHotspotNetwork.swift

@@ -0,0 +1,185 @@
+import Darwin
+import Foundation
+import Network
+import NetworkExtension
+
+/// Same persistent hotspot join as gallery (`joinOnce=false`). Only local traffic uses Wi-Fi.
+public final class GlassesHotspotNetwork {
+    private let queue = DispatchQueue(label: "com.mentra.glassesmedia.hotspot")
+    private var ssid: String?
+    private var localAddress: String?
+    private var generation = 0
+    private var applying = false
+    private var cancelled = false
+    private var joinReply: ((Result<String, Error>) -> Void)?
+    private var leaveReplies: [() -> Void] = []
+    private var monitor: NWPathMonitor?
+    public var onLost: ((String) -> Void)?
+    public init() {}
+
+    public func join(ssid: String, passphrase: String, 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 }
+            self.generation += 1
+            let gen = self.generation
+            self.ssid = ssid
+            self.cancelled = false
+            self.applying = true
+            self.joinReply = completion
+            let config = NEHotspotConfiguration(ssid: ssid, passphrase: passphrase, isWEP: false)
+            config.joinOnce = false
+            NEHotspotConfigurationManager.shared.apply(config) { error in
+                self.queue.async {
+                    guard gen == self.generation else { return }
+                    self.applying = false
+                    if self.cancelled { self.finishLeave(); return }
+                    if let error, (error as NSError).code != NEHotspotConfigurationError.alreadyAssociated.rawValue {
+                        self.finishJoin(.failure(error)); self.finishLeave(); return
+                    }
+                    self.waitForAddress(ssid: ssid, generation: gen, remaining: 60)
+                }
+            }
+            self.queue.asyncAfter(deadline: .now() + 60) {
+                guard gen == self.generation, self.joinReply != nil else { return }
+                self.cancelled = true
+                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.
+                NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid)
+                if !self.applying { self.finishLeave() }
+            }
+        }
+    }
+
+    public func leave(completion: @escaping () -> Void) {
+        queue.async {
+            self.cancelled = true
+            self.leaveReplies.append(completion)
+            self.finishJoin(.failure(LocalMediaError("Hotspot join cancelled")))
+            if let ssid = self.ssid { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
+            if !self.applying { self.finishLeave() }
+        }
+    }
+
+    public func info(completion: @escaping ([String: Any]) -> Void) {
+        queue.async {
+            var value: [String: Any] = ["available": self.localAddress != nil]
+            if let address = self.localAddress {
+                value["localIpv4"] = address
+                value["prefix"] = address.split(separator: ".").prefix(3).joined(separator: ".") + ".0/24"
+            }
+            completion(value)
+        }
+    }
+
+    public func probeGateway(completion: @escaping (Bool, String) -> Void) {
+        queue.async {
+            guard let address = self.localAddress else { completion(false, "No joined hotspot"); return }
+            let gateway = address.split(separator: ".").prefix(3).joined(separator: ".") + ".1"
+            let parameters = NWParameters.tcp
+            parameters.requiredInterfaceType = .wifi
+            let connection = NWConnection(host: NWEndpoint.Host(gateway), port: 8089, using: parameters)
+            var finished = false
+            let finish: (Bool, String) -> Void = { reachable, detail in
+                guard !finished else { return }
+                finished = true
+                connection.stateUpdateHandler = nil
+                connection.cancel()
+                completion(reachable, detail)
+            }
+            connection.stateUpdateHandler = { state in
+                switch state {
+                case .ready: finish(true, "\(gateway):8089")
+                case let .failed(error): finish(false, error.localizedDescription)
+                default: break
+                }
+            }
+            connection.start(queue: self.queue)
+            self.queue.asyncAfter(deadline: .now() + 3) { finish(false, "Gateway probe timed out") }
+        }
+    }
+
+    public func awaitInternet(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()
+                completion(usable, detail)
+            }
+            monitor.pathUpdateHandler = { path in
+                if path.status == .satisfied, path.usesInterfaceType(.cellular) { finish(true, "cellular") }
+            }
+            monitor.start(queue: self.queue)
+            self.queue.asyncAfter(deadline: .now() + 15) { finish(false, "Cellular internet did not become the default route") }
+        }
+    }
+
+    private func waitForAddress(ssid: String, generation gen: Int, remaining: Int) {
+        guard gen == generation, !cancelled else { return }
+        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.localAddress = address
+                    self.startMonitor(generation: gen)
+                    self.finishJoin(.success(address))
+                } else if remaining > 0 {
+                    self.queue.asyncAfter(deadline: .now() + 0.5) { self.waitForAddress(ssid: ssid, generation: gen, remaining: remaining - 1) }
+                } else {
+                    self.finishJoin(.failure(LocalMediaError("Glasses hotspot has no verified Wi-Fi address")))
+                    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 == self.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() != self.localAddress { self.onLost?("Glasses hotspot connection was lost") }
+        }
+        monitor.start(queue: queue)
+    }
+
+    private func finishJoin(_ result: Result<String, Error>) {
+        let reply = joinReply
+        joinReply = nil
+        reply?(result)
+    }
+
+    private func finishLeave() {
+        generation += 1
+        monitor?.cancel(); monitor = nil
+        if let ssid { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
+        ssid = nil
+        localAddress = nil
+        let replies = leaveReplies
+        leaveReplies.removeAll()
+        replies.forEach { $0() }
+    }
+
+    public static func wifiAddress() -> String? {
+        var interfaces: UnsafeMutablePointer<ifaddrs>?
+        guard getifaddrs(&interfaces) == 0 else { return nil }
+        defer { freeifaddrs(interfaces) }
+        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 }
+            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 }
+        }
+        return nil
+    }
+}

package/ios/GlassesMedia.podspec

@@ -0,0 +1,18 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+Pod::Spec.new do |s|
+  s.name = 'GlassesMedia'
+  s.version = package['version']
+  s.summary = package['description']
+  s.homepage = package['homepage']
+  s.license = package['license']
+  s.author = package['author']
+  s.source = { git: 'https://github.com/Mentra-Community/MentraOS.git' }
+  s.platforms = { :ios => '15.1' }
+  s.swift_version = '5.9'
+  s.static_framework = true
+  s.dependency 'WebRTC-SDK', '137.7151.09'
+  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'Network', 'NetworkExtension'
+  s.source_files = '*.{swift,h,m,mm}', 'CoreKit/Sources/GlassesMediaCore/*.swift'
+  s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
+end