@mentra/glasses-media 3.2.0-dev.225 → 3.2.0-dev.227

package/android/src/main/java/com/mentra/glassesmedia/source/WhipIngestServer.kt

@@ -69,6 +69,7 @@ class WhipIngestServer(
   private val connections = Executors.newCachedThreadPool { runnable ->
     Thread(runnable, "whip-ingest-conn").apply { isDaemon = true }
   }
+  private val activeSockets = java.util.concurrent.ConcurrentHashMap.newKeySet<Socket>()
   private val accepted = AtomicInteger()
 
   /** Bound endpoint, or null before [start]. This is the URL the glasses must be told to POST to. */
@@ -141,6 +142,13 @@ class WhipIngestServer(
     closeListener()
   }
 
+  /** Hard teardown barrier: no request may still create a peer after this returns. */
+  fun closeAndAwait(timeoutMs: Long = 15_000): Boolean {
+    closeNow()
+    connections.shutdownNow()
+    return connections.awaitTermination(timeoutMs, TimeUnit.MILLISECONDS)
+  }
+
   private fun closeListener() {
     val socket = synchronized(lock) {
       val current = server
@@ -149,6 +157,7 @@ class WhipIngestServer(
       current
     } ?: return
     runCatching { socket.close() }
+    activeSockets.forEach { runCatching { it.close() } }
     connections.shutdownNow()
     SoftApTrace.stage("whip_listener_closed", "accepted" to accepted.get())
   }
@@ -163,6 +172,10 @@ class WhipIngestServer(
         Log.w(TAG, "accept failed", error)
         return
       }
+      val registered = synchronized(lock) {
+        if (server !== socket) false else { activeSockets.add(connection); true }
+      }
+      if (!registered) { runCatching { connection.close() }; return }
       accepted.incrementAndGet()
       // Each connection on its own thread: a negotiation blocks for the length of an ICE gather,
       // and a DELETE arriving during one must not queue behind it.
@@ -170,28 +183,31 @@ class WhipIngestServer(
         connections.execute { serve(connection) }
       } catch (_: java.util.concurrent.RejectedExecutionException) {
         runCatching { connection.close() }
+        activeSockets.remove(connection)
       }
     }
   }
 
   private fun serve(connection: Socket) {
-    connection.use { socket ->
-      socket.soTimeout = READ_TIMEOUT_MS
-      val output = BufferedOutputStream(socket.getOutputStream())
-      try {
-        val request = readRequest(socket.getInputStream())
-        if (request == null) {
-          write(output, WhipIngestProtocol.Response(400, "Bad Request", body = "malformed request"))
-          return
-        }
-        write(output, handle(request))
-      } catch (error: Exception) {
-        Log.w(TAG, "connection failed", error)
-        runCatching {
-          write(output, WhipIngestProtocol.Response(400, "Bad Request", body = "read failed"))
+    try {
+      connection.use { socket ->
+        socket.soTimeout = READ_TIMEOUT_MS
+        val output = BufferedOutputStream(socket.getOutputStream())
+        try {
+          val request = readRequest(socket.getInputStream())
+          if (request == null) {
+            write(output, WhipIngestProtocol.Response(400, "Bad Request", body = "malformed request"))
+            return
+          }
+          write(output, handle(request))
+        } catch (error: Exception) {
+          Log.w(TAG, "connection failed", error)
+          runCatching {
+            write(output, WhipIngestProtocol.Response(400, "Bad Request", body = "read failed"))
+          }
         }
       }
-    }
+    } finally { activeSockets.remove(connection) }
   }
 
   private fun handle(request: WhipIngestProtocol.Request): WhipIngestProtocol.Response {

package/expo-module.config.json

@@ -4,9 +4,13 @@
     "android"
   ],
   "apple": {
-    "modules": []
+    "modules": [
+      "GlassesMediaRelayModule"
+    ]
   },
   "android": {
-    "modules": []
+    "modules": [
+      "com.mentra.glassesmedia.GlassesMediaRelayModule"
+    ]
   }
 }

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

@@ -31,6 +31,14 @@ public enum LocalMediaPolicy {
             (bytes[0] == 192 && bytes[1] == 168)
     }
 
+    /// SSID association can finish before DHCP replaces the previous Wi-Fi address.
+    /// Accept only a client address on the /24 advertised by the glasses over BLE.
+    public static func isHotspotClientAddress(_ address: String, gateway: String) -> Bool {
+        guard isPrivate(gateway), sameSubnet(address, gateway), address != gateway,
+              let bytes = ipv4(address) else { return false }
+        return bytes[3] > 0 && bytes[3] < 255
+    }
+
     /// 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 {

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

@@ -0,0 +1,56 @@
+import Foundation
+
+/// A paced audio worker whose stop is a barrier for the final render callback and its resources.
+public final class RelayAudioClock {
+    private let condition = NSCondition()
+    private var quitting = false
+    private var exited = true
+    private var enabled = false
+
+    public init() {}
+
+    public func start(render: @escaping (Double) -> Void, finish: @escaping () -> Void = {}) {
+        condition.lock()
+        precondition(exited, "Previous audio worker must stop before reinitialization")
+        quitting = false; enabled = false; exited = false
+        condition.unlock()
+        let thread = Thread { [self] in
+            defer {
+                finish()
+                condition.lock(); exited = true; condition.broadcast(); condition.unlock()
+            }
+            var sampleTime: Double = 0
+            var next = ProcessInfo.processInfo.systemUptime
+            while true {
+                condition.lock()
+                while !enabled && !quitting {
+                    condition.wait(); next = ProcessInfo.processInfo.systemUptime
+                }
+                let stop = quitting
+                condition.unlock()
+                if stop { return }
+                render(sampleTime)
+                sampleTime += 480
+                next += 0.01
+                let now = ProcessInfo.processInfo.systemUptime
+                if next > now { Thread.sleep(forTimeInterval: next - now) }
+                else if now - next > 0.1 { next = now }
+            }
+        }
+        thread.name = "Mentra glasses audio publish"
+        thread.qualityOfService = .userInitiated
+        thread.start()
+    }
+
+    public func setEnabled(_ value: Bool) {
+        condition.lock(); enabled = value; condition.broadcast(); condition.unlock()
+    }
+
+    public func stop() {
+        condition.lock(); quitting = true; enabled = false; condition.broadcast()
+        while !exited {
+            condition.wait()
+        }
+        condition.unlock()
+    }
+}

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

@@ -0,0 +1,57 @@
+import Foundation
+
+/// Bounded decoded audio queue. Converts PCM16 to 48kHz mono without touching phone capture.
+public final class RelayPcmBuffer {
+    private let lock = NSLock()
+    private var samples: [Int16]
+    private var head = 0
+    private var count = 0
+    private var phase = 0.0
+    private var rate = 0
+    private var channels = 0
+    private var previous: Double?
+
+    public init(capacity: Int = 9600) {
+        samples = Array(repeating: 0, count: capacity)
+    }
+
+    public func push(_ data: Data, sampleRate: Int, channels channelCount: Int) {
+        guard (8000 ... 192_000).contains(sampleRate), (1 ... 8).contains(channelCount) else { return }
+        lock.lock(); defer { lock.unlock() }
+        if rate != sampleRate || channels != channelCount {
+            rate = sampleRate; channels = channelCount; phase = 0; previous = nil
+        }
+        let step = Double(sampleRate) / 48000
+        data.withUnsafeBytes { raw in
+            let bytes = raw.bindMemory(to: UInt8.self)
+            for frame in 0 ..< data.count / (2 * channelCount) {
+                var sum = 0.0
+                for channel in 0 ..< channelCount {
+                    let offset = (frame * channelCount + channel) * 2
+                    sum += Double(Int16(bitPattern: UInt16(bytes[offset]) | UInt16(bytes[offset + 1]) << 8))
+                }
+                let value = sum / Double(channelCount)
+                if let prior = previous {
+                    while phase < 1 {
+                        if count == samples.count { head = (head + 1) % samples.count; count -= 1 }
+                        samples[(head + count) % samples.count] = Int16(prior + (value - prior) * phase)
+                        count += 1
+                        phase += step
+                    }
+                    phase -= 1
+                }
+                previous = value
+            }
+        }
+    }
+
+    /// Pads underruns with silence. Drops oldest samples on overrun to bound live latency.
+    public func read(into output: UnsafeMutableBufferPointer<Int16>) {
+        lock.lock(); defer { lock.unlock() }
+        for i in output.indices {
+            if count > 0 {
+                output[i] = samples[head]; head = (head + 1) % samples.count; count -= 1
+            } else { output[i] = 0 }
+        }
+    }
+}

package/ios/GlassesHotspotNetwork.swift

@@ -8,6 +8,7 @@ public final class GlassesHotspotNetwork {
     private let queue = DispatchQueue(label: "com.mentra.glassesmedia.hotspot")
     private var ssid: String?
     private var localAddress: String?
+    private var gatewayAddress: String?
     private var generation = 0
     private var applying = false
     private var cancelled = false
@@ -17,12 +18,16 @@ public final class GlassesHotspotNetwork {
     public var onLost: ((String) -> Void)?
     public init() {}
 
-    public func join(ssid: String, passphrase: String, completion: @escaping (Result<String, Error>) -> Void) {
+    public func join(ssid: String, passphrase: String, gateway: String? = nil, 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 }
+            if let gateway, !LocalMediaPolicy.isPrivate(gateway) {
+                completion(.failure(LocalMediaError("The glasses reported an invalid hotspot gateway"))); return
+            }
             self.generation += 1
             let gen = self.generation
             self.ssid = ssid
+            self.gatewayAddress = gateway
             self.cancelled = false
             self.applying = true
             self.joinReply = completion
@@ -75,7 +80,7 @@ public final class GlassesHotspotNetwork {
     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 gateway = self.gatewayAddress ?? 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)
@@ -122,7 +127,9 @@ public final class GlassesHotspotNetwork {
         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() {
+                if network?.ssid == ssid, let address = Self.wifiAddress(),
+                   self.gatewayAddress.map({ LocalMediaPolicy.isHotspotClientAddress(address, gateway: $0) }) ?? true
+                {
                     self.localAddress = address
                     self.startMonitor(generation: gen)
                     self.finishJoin(.success(address))
@@ -160,6 +167,7 @@ public final class GlassesHotspotNetwork {
         if let ssid { NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid) }
         ssid = nil
         localAddress = nil
+        gatewayAddress = nil
         let replies = leaveReplies
         leaveReplies.removeAll()
         replies.forEach { $0() }

package/ios/GlassesMedia.podspec

@@ -11,6 +11,7 @@ Pod::Spec.new do |s|
   s.platforms = { :ios => '15.1' }
   s.swift_version = '5.9'
   s.static_framework = true
+  s.dependency 'ExpoModulesCore'
   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'

package/ios/GlassesMediaRelayModule.swift

@@ -0,0 +1,133 @@
+import ExpoModulesCore
+import Foundation
+
+public final class GlassesMediaRelayModule: Module {
+    private let queue = DispatchQueue(label: "com.mentra.glassesmedia.relay")
+    private var session: ManagedRelaySession?
+
+    public func definition() -> ModuleDefinition {
+        Name("MentraGlassesMediaRelay")
+        Events("onRelayState")
+
+        AsyncFunction("prepare") { (options: [String: Any], promise: Promise) in
+            guard let id = options["attemptId"] as? String,
+                  let ingest = options["ingestUrl"] as? String, let url = URL(string: ingest), url.scheme == "https",
+                  let ssid = options["ssid"] as? String, let password = options["password"] as? String,
+                  let gateway = options["gatewayAddress"] as? String
+            else {
+                throw LocalMediaError("Invalid relay options")
+            }
+            self.queue.async {
+                guard self.session == nil else { promise.reject(LocalMediaError("Previous relay has not stopped")); return }
+                let session = ManagedRelaySession(id: id, queue: self.queue)
+                self.session = session
+                session.start(ssid: ssid, password: password, gateway: gateway, endpoint: url,
+                              captureAudio: options["captureAudio"] as? Bool ?? true,
+                              bitrate: options["bitrate"] as? Int ?? 2_000_000,
+                              onState: { [weak self] state, reason in
+                                  self?.sendEvent("onRelayState", ["attemptId": id, "state": state, "reason": reason])
+                              }) { result in
+                    switch result {
+                    case let .success(url): promise.resolve(url)
+                    case let .failure(error): promise.reject(error)
+                    }
+                }
+            }
+        }
+
+        AsyncFunction("stop") { (id: String, promise: Promise) in
+            self.queue.async {
+                guard let session = self.session, session.id == id else { promise.resolve(nil); return }
+                session.stop {
+                    if self.session === session { self.session = nil }
+                    promise.resolve(nil)
+                }
+            }
+        }
+
+        OnDestroy {
+            self.queue.async {
+                self.session?.stop { self.session = nil }
+            }
+        }
+    }
+}
+
+/// Serialized owner of both native peers and the persistent hotspot join; no JS media callbacks.
+private final class ManagedRelaySession {
+    let id: String
+    private let queue: DispatchQueue
+    private let hotspot = GlassesHotspotNetwork()
+    private var receiver: LocalWhipIngestSource?
+    private var publisher: PhoneWhipPublisher?
+    private var stopped = false
+    private var stopFinished = false
+    private var stopReplies: [() -> Void] = []
+    private var ready: ((Result<String, Error>) -> Void)?
+
+    init(id: String, queue: DispatchQueue) {
+        self.id = id; self.queue = queue
+    }
+
+    func start(ssid: String, password: String, gateway: String, endpoint: URL, captureAudio: Bool, bitrate: Int,
+               onState: @escaping (String, String) -> Void, completion: @escaping (Result<String, Error>) -> Void)
+    {
+        ready = completion
+        hotspot.onLost = { reason in onState("failed", reason) }
+        hotspot.join(ssid: ssid, passphrase: password, gateway: gateway) { result in
+            self.queue.async {
+                guard !self.stopped else { return }
+                switch result {
+                case let .failure(error): self.finish(.failure(error))
+                case let .success(address):
+                    self.hotspot.awaitInternet { usable, _ in
+                        self.queue.async {
+                            guard !self.stopped else { return }
+                            guard usable else { self.finish(.failure(LocalMediaError("Turn on phone mobile data to stream through the glasses hotspot"))); return }
+                            let publisher = PhoneWhipPublisher(endpoint: endpoint, captureAudio: captureAudio, bitrate: bitrate, onState: onState)
+                            self.publisher = publisher
+                            let receiver = LocalWhipIngestSource()
+                            self.receiver = receiver
+                            receiver.onFrame = { [weak publisher] in publisher?.onFrame($0) }
+                            receiver.onPcm = { [weak publisher] in publisher?.onPcm($0, rate: $1, channels: $2) }
+                            receiver.onStateChange = { state, reason in if state == .failed { onState("failed", "Glasses receiver: \(reason)") } }
+                            receiver.setPcmDeliveryEnabled(captureAudio)
+                            receiver.prepare(config: SourceConfig(url: "", kind: .softap, bindAddress: address)) { result in
+                                self.queue.async {
+                                    guard !self.stopped else { return }
+                                    if case .success = result { publisher.start() }
+                                    self.finish(result)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private func finish(_ result: Result<String, Error>) {
+        let callback = ready; ready = nil; callback?(result)
+    }
+
+    func stop(completion: @escaping () -> Void) {
+        if stopFinished { completion(); return }
+        stopReplies.append(completion)
+        guard !stopped else { return }
+        stopped = true
+        finish(.failure(LocalMediaError("Relay cancelled")))
+        hotspot.onLost = nil
+        let group = DispatchGroup()
+        if let receiver {
+            group.enter(); receiver.stop { group.leave() }
+        }
+        if let publisher {
+            group.enter(); publisher.stop { group.leave() }
+        }
+        group.enter(); hotspot.leave { group.leave() }
+        group.notify(queue: queue) {
+            self.receiver = nil; self.publisher = nil; self.stopFinished = true
+            let replies = self.stopReplies; self.stopReplies.removeAll(); replies.forEach { $0() }
+        }
+    }
+}

package/ios/PhoneWhipPublisher.swift

@@ -0,0 +1,202 @@
+import CoreVideo
+import Foundation
+import WebRTC
+
+/// ASG's full-ICE WHIP negotiation, fed from the shared decoded receiver. One peer per attempt.
+final class PhoneWhipPublisher: NSObject {
+    private let queue = DispatchQueue(label: "com.mentra.glassesmedia.whip.publish")
+    private let frameSlot = DispatchSemaphore(value: 1)
+    private let endpoint: URL
+    private let captureAudio: Bool
+    private let bitrate: Int
+    private let onState: (String, String) -> Void
+    private let audioDevice = RelayAudioDevice()
+    private var factory: RTCPeerConnectionFactory?
+    private var peer: RTCPeerConnection?
+    private var videoSource: RTCVideoSource?
+    private var capturer: RTCVideoCapturer?
+    private var resource: URL?
+    private var posted = false
+    private var localSet = false
+    private var stopped = false
+    private var failed = false
+    private var connected = false
+    private var disconnectGeneration = 0
+    private var lastTimestamp: Int64 = 0
+    private let http: URLSession
+
+    init(endpoint: URL, captureAudio: Bool, bitrate: Int, onState: @escaping (String, String) -> Void) {
+        self.endpoint = endpoint; self.captureAudio = captureAudio; self.bitrate = bitrate; self.onState = onState
+        let config = URLSessionConfiguration.ephemeral
+        config.allowsCellularAccess = true
+        config.timeoutIntervalForRequest = 20
+        config.timeoutIntervalForResource = 25
+        http = URLSession(configuration: config)
+        super.init()
+    }
+
+    func start() {
+        queue.async {
+            guard !self.stopped else { return }
+            RTCInitializeSSL()
+            let factory = RTCPeerConnectionFactory(encoderFactory: RTCDefaultVideoEncoderFactory(), decoderFactory: RTCDefaultVideoDecoderFactory(), audioDevice: self.audioDevice)
+            let options = RTCPeerConnectionFactoryOptions()
+            options.ignoreWiFiNetworkAdapter = true
+            options.ignoreVPNNetworkAdapter = true
+            options.ignoreLoopbackNetworkAdapter = true
+            factory.setOptions(options)
+            self.factory = factory
+            let config = RTCConfiguration()
+            config.sdpSemantics = .unifiedPlan
+            config.iceServers = [RTCIceServer(urlStrings: ["stun:stun.cloudflare.com:3478"])]
+            let constraints = RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil)
+            guard let peer = factory.peerConnection(with: config, constraints: constraints, delegate: self) else {
+                self.fail("Could not create WHIP peer"); return
+            }
+            self.peer = peer
+            let source = factory.videoSource()
+            self.videoSource = source
+            self.capturer = RTCVideoCapturer(delegate: source)
+            let video = factory.videoTrack(with: source, trackId: "glasses-video")
+            let sendOnly = RTCRtpTransceiverInit()
+            sendOnly.direction = .sendOnly
+            let transceiver = peer.addTransceiver(with: video, init: sendOnly)
+            let codecs = factory.rtpSenderCapabilities(forKind: kRTCMediaStreamTrackKindVideo).codecs.filter { $0.name.lowercased() == "h264" }
+            if !codecs.isEmpty { try? transceiver?.setCodecPreferences(codecs, error: ()) }
+            if let sender = transceiver?.sender {
+                let parameters = sender.parameters
+                parameters.encodings.forEach { $0.maxBitrateBps = NSNumber(value: min(12_000_000, max(250_000, self.bitrate))) }
+                sender.parameters = parameters
+            }
+            if self.captureAudio {
+                let audioConstraints = RTCMediaConstraints(mandatoryConstraints: ["googEchoCancellation": "false", "googNoiseSuppression": "false", "googAutoGainControl": "false"], optionalConstraints: nil)
+                let audio = factory.audioTrack(with: factory.audioSource(with: audioConstraints), trackId: "glasses-audio")
+                peer.addTransceiver(with: audio, init: sendOnly)
+            }
+            peer.offer(for: constraints) { [weak self] offer, error in
+                self?.queue.async {
+                    guard let self, !self.stopped else { return }
+                    guard let offer, error == nil else { self.fail("WHIP offer failed"); return }
+                    peer.setLocalDescription(offer) { error in
+                        self.queue.async {
+                            guard !self.stopped else { return }
+                            guard error == nil else { self.fail("WHIP local description failed"); return }
+                            self.localSet = true; self.maybePost()
+                        }
+                    }
+                }
+            }
+            self.queue.asyncAfter(deadline: .now() + 35) {
+                if !self.connected { self.fail("WHIP connection timed out") }
+            }
+        }
+    }
+
+    func onFrame(_ buffer: CVPixelBuffer) {
+        guard frameSlot.wait(timeout: .now()) == .success else { return }
+        queue.async {
+            defer { self.frameSlot.signal() }
+            guard !self.stopped, let source = self.videoSource, let capturer = self.capturer else { return }
+            self.lastTimestamp = max(Int64(ProcessInfo.processInfo.systemUptime * 1_000_000_000), self.lastTimestamp + 1)
+            let frame = RTCVideoFrame(buffer: RTCCVPixelBuffer(pixelBuffer: buffer), rotation: ._0, timeStampNs: self.lastTimestamp)
+            source.capturer(capturer, didCapture: frame)
+        }
+    }
+
+    func onPcm(_ data: Data, rate: Int, channels: Int) {
+        if captureAudio { audioDevice.pcm.push(data, sampleRate: rate, channels: channels) }
+    }
+
+    private func maybePost() {
+        guard !stopped, !posted, localSet, let peer, peer.iceGatheringState == .complete, let offer = peer.localDescription else { return }
+        posted = true
+        var request = URLRequest(url: endpoint)
+        request.httpMethod = "POST"
+        request.setValue("application/sdp", forHTTPHeaderField: "Content-Type")
+        request.httpBody = Data(offer.sdp.utf8)
+        // Retain this attempt through a late response, so stop cannot orphan a created WHIP resource.
+        http.dataTask(with: request) { data, response, error in
+            self.queue.async {
+                let response = response as? HTTPURLResponse
+                let location = response?.value(forHTTPHeaderField: "Location").flatMap { URL(string: $0, relativeTo: self.endpoint)?.absoluteURL }
+                if self.stopped {
+                    if let location { self.delete(location) }
+                    self.http.finishTasksAndInvalidate()
+                    return
+                }
+                guard error == nil, response?.statusCode == 201, let location, location.scheme == "https",
+                      let data, let answer = String(data: data, encoding: .utf8), !answer.isEmpty
+                else {
+                    if let location { self.delete(location) }
+                    self.fail("WHIP server rejected publish (HTTP \(response?.statusCode ?? 0))"); return
+                }
+                self.resource = location
+                peer.setRemoteDescription(RTCSessionDescription(type: .answer, sdp: answer)) { error in
+                    self.queue.async { if error != nil { self.fail("WHIP answer failed") } }
+                }
+            }
+        }.resume()
+    }
+
+    private func delete(_ url: URL) {
+        guard url.scheme == "https" else { return }
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+        http.dataTask(with: request) { _, _, _ in }.resume()
+    }
+
+    private func fail(_ reason: String) {
+        guard !stopped, !failed else { return }
+        failed = true; onState("failed", reason)
+    }
+
+    func stop(completion: @escaping () -> Void) {
+        queue.async {
+            if !self.stopped {
+                self.stopped = true
+                self.peer?.close()
+                // Drain the external audio callback while its native delegate/factory is still alive.
+                _ = self.audioDevice.terminateDevice()
+                self.peer = nil
+                self.videoSource = nil; self.capturer = nil; self.factory = nil
+                if let resource = self.resource { self.delete(resource); self.resource = nil; self.http.finishTasksAndInvalidate() }
+                else if !self.posted { self.http.finishTasksAndInvalidate() }
+                // An in-flight POST completes cleanup in its callback above.
+            }
+            completion()
+        }
+    }
+}
+
+extension PhoneWhipPublisher: RTCPeerConnectionDelegate {
+    func peerConnection(_: RTCPeerConnection, didChange _: RTCSignalingState) {}
+    func peerConnection(_: RTCPeerConnection, didAdd _: RTCMediaStream) {}
+    func peerConnection(_: RTCPeerConnection, didRemove _: RTCMediaStream) {}
+    func peerConnectionShouldNegotiate(_: RTCPeerConnection) {}
+    func peerConnection(_ peerConnection: RTCPeerConnection, didChange state: RTCIceConnectionState) {
+        queue.async {
+            guard self.peer === peerConnection, !self.stopped else { return }
+            switch state {
+            case .connected, .completed:
+                self.connected = true; self.disconnectGeneration += 1
+                self.onState("connected", "Phone publisher connected")
+            case .disconnected:
+                self.disconnectGeneration += 1
+                let gen = self.disconnectGeneration
+                self.queue.asyncAfter(deadline: .now() + 10) {
+                    if gen == self.disconnectGeneration { self.fail("Phone internet connection was lost") }
+                }
+            case .failed: self.fail("WHIP ICE failed")
+            default: break
+            }
+        }
+    }
+
+    func peerConnection(_ peerConnection: RTCPeerConnection, didChange _: RTCIceGatheringState) {
+        queue.async { if self.peer === peerConnection { self.maybePost() } }
+    }
+
+    func peerConnection(_: RTCPeerConnection, didGenerate _: RTCIceCandidate) {}
+    func peerConnection(_: RTCPeerConnection, didRemove _: [RTCIceCandidate]) {}
+    func peerConnection(_: RTCPeerConnection, didOpen _: RTCDataChannel) {}
+}