@mentra/acs-meeting 3.2.0-dev.223 → 3.2.0-dev.225

package/ios/PolicyKit/Sources/AcsAudioPolicy/CallbackOperation.swift

@@ -49,3 +49,63 @@ public enum CallbackOperationError: Error {
   case missingResult
   case timedOut
 }
+
+/// Retires one call agent when hang-up completes or its deadline expires. The
+/// session invokes finish on its serial queue; disposal must precede opening the
+/// barrier, and a late SDK callback must not release a newer call's reservation.
+final class CallAgentRetirement {
+  private let group: DispatchGroup
+  private var dispose: (() -> Void)?
+
+  init(group: DispatchGroup, queue: DispatchQueue, timeout: TimeInterval = 10, dispose: @escaping () -> Void) {
+    self.group = group
+    self.dispose = dispose
+    group.enter()
+    queue.asyncAfter(deadline: .now() + timeout) { self.finish() }
+  }
+
+  func finish() {
+    guard let dispose else { return }
+    self.dispose = nil
+    dispose()
+    group.leave()
+  }
+}
+
+/// Keeps an in-flight join's agent alive after cancellation until its returned
+/// call is hung up. All methods run on the session queue, as do hang-up callbacks.
+final class CallJoinRetirement<Call> {
+  private let group: DispatchGroup
+  private let queue: DispatchQueue
+  private let timeout: TimeInterval
+  private let dispose: () -> Void
+  private let hangUp: (Call, @escaping () -> Void) -> Void
+  private var retirement: CallAgentRetirement?
+  private var completed = false
+
+  init(group: DispatchGroup, queue: DispatchQueue, timeout: TimeInterval = 10,
+       dispose: @escaping () -> Void, hangUp: @escaping (Call, @escaping () -> Void) -> Void)
+  {
+    self.group = group
+    self.queue = queue
+    self.timeout = timeout
+    self.dispose = dispose
+    self.hangUp = hangUp
+  }
+
+  func cancel() {
+    guard !completed, retirement == nil else { return }
+    retirement = CallAgentRetirement(group: group, queue: queue, timeout: timeout, dispose: dispose)
+  }
+
+  /// Returns true only when the session may adopt this join result.
+  func receive(_ call: Call?) -> Bool {
+    guard !completed else { return false }
+    completed = true
+    guard let retirement else { return true }
+    if let call {
+      hangUp(call) { self.queue.async { retirement.finish() } }
+    } else { retirement.finish() }
+    return false
+  }
+}

package/ios/PolicyKit/Sources/AcsAudioPolicy/CapturePolicy.swift

@@ -0,0 +1,5 @@
+public enum CapturePolicy {
+    public static func captureGlassesMic(_ source: AudioSourceKind) -> Bool {
+        source == .glasses
+    }
+}

package/ios/PolicyKit/Tests/AcsAudioPolicyTests/AcsAudioPolicyTests.swift

@@ -1,3 +1,4 @@
+import GlassesMediaCore
 import XCTest
 @testable import AcsAudioPolicy
 

package/ios/PolicyKit/Tests/AcsAudioPolicyTests/CallAgentRetirementTests.swift

@@ -0,0 +1,113 @@
+@testable import AcsAudioPolicy
+import Foundation
+import XCTest
+
+final class CallAgentRetirementTests: XCTestCase {
+  func testCancelledJoinWithNoCallbackStillRetiresAtDeadline() {
+    let queue = DispatchQueue(label: "retirement.missing-join")
+    let group = DispatchGroup()
+    var disposals = 0
+    queue.sync {
+      let join = CallJoinRetirement<Int>(group: group, queue: queue, timeout: 0.01, dispose: { disposals += 1 }) { _, _ in
+        XCTFail("No call was returned to hang up")
+      }
+      join.cancel()
+      XCTAssertEqual(group.wait(timeout: .now()), .timedOut)
+    }
+    XCTAssertEqual(group.wait(timeout: .now() + 1), .success)
+    queue.sync { XCTAssertEqual(disposals, 1) }
+  }
+
+  func testSuccessfulJoinTransfersOwnershipWithoutDisposal() {
+    let queue = DispatchQueue(label: "retirement.successful-join")
+    let group = DispatchGroup()
+    queue.sync {
+      let join = CallJoinRetirement<Int>(group: group, queue: queue, dispose: { XCTFail("Session owns this agent") }) { _, _ in
+        XCTFail("Session owns this call")
+      }
+      XCTAssertTrue(join.receive(42))
+      join.cancel()
+      XCTAssertEqual(group.wait(timeout: .now()), .success)
+    }
+  }
+
+  func testCancelledJoinRetainsAgentUntilLateCallFinishesHangingUp() {
+    let queue = DispatchQueue(label: "retirement.cancelled-join")
+    let group = DispatchGroup()
+    let joinReturned = expectation(description: "cancelled join returned a call")
+    var disposals = 0
+    var hangUpCompleted: (() -> Void)?
+    queue.sync {
+      let join = CallJoinRetirement<Int>(group: group, queue: queue, dispose: { disposals += 1 }) { call, finished in
+        XCTAssertEqual(call, 42)
+        XCTAssertEqual(disposals, 0)
+        hangUpCompleted = finished
+        joinReturned.fulfill()
+      }
+      join.cancel()
+      join.cancel()
+      XCTAssertFalse(join.receive(42))
+    }
+    wait(for: [joinReturned], timeout: 1)
+    queue.sync {
+      XCTAssertEqual(group.wait(timeout: .now()), .timedOut)
+      XCTAssertEqual(disposals, 0)
+      hangUpCompleted?()
+    }
+    XCTAssertEqual(group.wait(timeout: .now() + 1), .success)
+    queue.sync { XCTAssertEqual(disposals, 1) }
+  }
+
+  func testMissingHangUpCallbackDisposesAgentBeforeUnblockingLeave() {
+    let queue = DispatchQueue(label: "retirement.timeout")
+    let group = DispatchGroup()
+    var disposals = 0
+    queue.sync {
+      _ = CallAgentRetirement(group: group, queue: queue, timeout: 0.01) {
+        XCTAssertEqual(group.wait(timeout: .now()), .timedOut)
+        disposals += 1
+      }
+      XCTAssertEqual(group.wait(timeout: .now()), .timedOut)
+    }
+    XCTAssertEqual(group.wait(timeout: .now() + 1), .success)
+    queue.sync { XCTAssertEqual(disposals, 1) }
+  }
+
+  func testLateCallbackCannotReleaseNextCallsCleanupBarrier() {
+    let queue = DispatchQueue(label: "retirement.late")
+    let group = DispatchGroup()
+    var old: CallAgentRetirement!
+    var disposals = 0
+    queue.sync {
+      old = CallAgentRetirement(group: group, queue: queue, timeout: 0.01) { disposals += 1 }
+    }
+    XCTAssertEqual(group.wait(timeout: .now() + 1), .success)
+    queue.sync {
+      let next = CallAgentRetirement(group: group, queue: queue) { disposals += 1 }
+      old.finish()
+      XCTAssertEqual(disposals, 1)
+      XCTAssertEqual(group.wait(timeout: .now()), .timedOut)
+      next.finish()
+      XCTAssertEqual(disposals, 2)
+      XCTAssertEqual(group.wait(timeout: .now()), .success)
+    }
+  }
+
+  func testHangUpCompletionAndDeadlineDisposeExactlyOnce() {
+    let queue = DispatchQueue(label: "retirement.completed")
+    let group = DispatchGroup()
+    let deadlinePassed = expectation(description: "deadline fired after callback")
+    var disposals = 0
+    queue.sync {
+      let retirement = CallAgentRetirement(group: group, queue: queue, timeout: 0.01) { disposals += 1 }
+      retirement.finish()
+      retirement.finish()
+      XCTAssertEqual(group.wait(timeout: .now()), .success)
+      queue.asyncAfter(deadline: .now() + 0.03) {
+        XCTAssertEqual(disposals, 1)
+        deadlinePassed.fulfill()
+      }
+    }
+    wait(for: [deadlinePassed], timeout: 1)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/acs-meeting",
-  "version": "3.2.0-dev.223",
+  "version": "3.2.0-dev.225",
   "description": "MentraOS native ACS Teams meeting module (WHEP decode → ACS raw media)",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -31,7 +31,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@expo/config-plugins": "~55.0.10"
+    "@expo/config-plugins": "~55.0.10",
+    "@mentra/glasses-media": "3.2.0-dev.225"
   },
   "devDependencies": {
     "expo-module-scripts": "^55.0.2",

package/src/AcsMeeting.types.ts

@@ -30,6 +30,8 @@ export type AcsMeetingState = {
   activeStream?: AcsActiveStream
   audioSafety?: AcsAudioSafety
   mediaSource?: AcsMediaSourceState
+  /** Local WHIP endpoint, available after a SoftAP join. */
+  ingestUrl?: string
   /** Remote roster (Android emits this; iOS does not yet). */
   participants?: AcsMeetingParticipant[]
 }
@@ -44,7 +46,8 @@ export type AcsOutgoingVideo = {
 export type AcsMeetingJoinOptions = {
   meetingUrl: string
   token: string
-  whepUrl: string
+  whepUrl?: string
+  videoSource?: {type: "whep"; url: string} | {type: "softap"; bindAddress: string}
   displayName?: string
   /** "glasses" sends WHEP PCM. "phone" uses the ACS local mic (handset or BT). */
   audioSource?: AcsAudioSource

package/src/AcsMeetingModule.ts

@@ -9,7 +9,7 @@ declare class AcsMeetingNativeModule extends NativeModule<AcsMeetingModuleEvents
   leave(): Promise<void>
   /**
    * Leave, and resolve only once the hang-up, the agent disposal, and the network releases have
-   * finished. `leave()` only queues that work, so awaiting it proves nothing about cleanup.
+   * finished. Use this explicit barrier across platforms; Android `leave()` only queues cleanup.
    */
   leaveAndAwait(options: {timeoutMs: number}): Promise<{completed: boolean}>
   setMuted(muted: boolean): Promise<AcsMeetingState>
@@ -17,7 +17,7 @@ declare class AcsMeetingNativeModule extends NativeModule<AcsMeetingModuleEvents
   updateVideoSource(whepUrl: string): Promise<void>
   /** Force a WHEP rebuild on the current URL (phone changed networks). */
   restartVideoSource(): Promise<void>
-  /** SoftAP: join the glasses hotspot as a scoped network; resolves to the phone's IPv4 on it. Android only. */
+  /** SoftAP: join the glasses hotspot; resolves to the phone's IPv4 on it. */
   joinScopedNetwork(ssid: string, passphrase: string): Promise<string>
   beginTrace(traceId: string): Promise<void>
   leaveScopedNetwork(): Promise<void>

package/android/src/androidTest/java/com/mentra/acsmeeting/network/SoftApFeasibilityGateTest.kt

@@ -1,291 +0,0 @@
-package com.mentra.acsmeeting.network
-
-import android.content.Context
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import androidx.test.platform.app.InstrumentationRegistry
-import java.net.DatagramPacket
-import java.net.DatagramSocket
-import java.net.InetAddress
-import java.net.InetSocketAddress
-import java.net.ServerSocket
-import java.net.Socket
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Assume.assumeTrue
-import org.junit.Before
-import org.junit.Test
-import org.webrtc.DefaultVideoDecoderFactory
-import org.webrtc.DefaultVideoEncoderFactory
-import org.webrtc.EglBase
-import org.webrtc.IceCandidate
-import org.webrtc.MediaConstraints
-import org.webrtc.PeerConnection
-import org.webrtc.PeerConnectionFactory
-import org.webrtc.SdpObserver
-import org.webrtc.SessionDescription
-
-/**
- * PHASE 0.5 HARD GATE — the six facts the SoftAP architecture depends on.
- *
- * This is a real-device test, deliberately excluded from CI: it needs a phone with cellular data
- * active and the glasses hotspot broadcasting. Run it before building the WHIP ingest server. If
- * [libwebrtc emits a hotspot host candidate][iceGatheringProducesAHotspotHostCandidate] fails, stock
- * libwebrtc is not enumerating the no-INTERNET network and [ScopedNetworkChangeDetector] must be
- * installed and this re-run before Phase 3 proceeds.
- *
- * ```
- * cd mobile/android && ./gradlew :mentra-acs-meeting:connectedDebugAndroidTest \
- *   -Pandroid.testInstrumentationRunnerArguments.softApSsid=MentraLive-1234 \
- *   -Pandroid.testInstrumentationRunnerArguments.softApPassphrase=<passphrase>
- * ```
- *
- * Without those arguments every test is skipped rather than failing, so an accidental CI run is
- * inert rather than red.
- *
- * The three glasses-initiated facts (inbound TCP, inbound UDP, cleartext WHIP POST) are the reason
- * gallery sync is not sufficient evidence: sync only proves phone -> glasses, and here the glasses
- * connect *to* a server on the phone. AP client isolation, firewall rules, or Android's inbound
- * local-network policy can each break that while sync keeps working. This class proves the phone
- * side accepts inbound connections on the hotspot address; driving the glasses to actually dial in
- * is the Phase 7 device proof.
- */
-class SoftApFeasibilityGateTest {
-
-    private lateinit var context: Context
-    private lateinit var scoped: ScopedSoftApNetwork
-    private var ssid: String = ""
-    private var passphrase: String = ""
-
-    @Before
-    fun setUp() {
-        val arguments = InstrumentationRegistry.getArguments()
-        ssid = arguments.getString("softApSsid").orEmpty()
-        passphrase = arguments.getString("softApPassphrase").orEmpty()
-        assumeTrue("softApSsid instrumentation argument is required", ssid.isNotEmpty())
-
-        context = InstrumentationRegistry.getInstrumentation().targetContext
-        scoped = ScopedSoftApNetwork(context)
-    }
-
-    // -----------------------------------------------------------------
-    // (6) ACS/internet traffic stays on cellular
-    // -----------------------------------------------------------------
-
-    @Test
-    fun scopedJoinKeepsCellularAsTheDefaultNetwork() {
-        scoped.join(ssid, passphrase)
-        try {
-            assertThat(scoped.isAvailable()).isTrue()
-            assertThat(scoped.localIpv4()).isNotNull()
-
-            val manager = context.getSystemService(ConnectivityManager::class.java)
-            val default = requireNotNull(manager.activeNetwork) { "no default network" }
-            val capabilities = requireNotNull(manager.getNetworkCapabilities(default))
-
-            assertThat(capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
-                .describedAs("default network must remain cellular after the scoped join")
-                .isTrue()
-            assertThat(capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
-                .isTrue()
-        } finally {
-            scoped.release()
-        }
-    }
-
-    // -----------------------------------------------------------------
-    // (1) inbound TCP on the hotspot address
-    // -----------------------------------------------------------------
-
-    @Test
-    fun phoneAcceptsInboundTcpOnTheHotspotAddress() {
-        scoped.join(ssid, passphrase)
-        try {
-            val local = InetAddress.getByName(requireNotNull(scoped.localIpv4()))
-            val accepted = CountDownLatch(1)
-
-            ServerSocket().use { server ->
-                server.reuseAddress = true
-                server.bind(InetSocketAddress(local, 0))
-
-                Thread {
-                    runCatching { server.accept().use { accepted.countDown() } }
-                }
-                    .apply { isDaemon = true }
-                    .start()
-
-                Socket().use { client ->
-                    client.connect(InetSocketAddress(local, server.localPort), CONNECT_TIMEOUT_MS)
-                }
-
-                assertThat(accepted.await(5, TimeUnit.SECONDS))
-                    .describedAs("inbound TCP on %s was not accepted", local)
-                    .isTrue()
-            }
-        } finally {
-            scoped.release()
-        }
-    }
-
-    // -----------------------------------------------------------------
-    // (2) inbound UDP on the hotspot address
-    // -----------------------------------------------------------------
-
-    @Test
-    fun phoneReceivesUdpOnTheHotspotAddress() {
-        scoped.join(ssid, passphrase)
-        try {
-            val local = InetAddress.getByName(requireNotNull(scoped.localIpv4()))
-
-            DatagramSocket(null).use { receiver ->
-                receiver.reuseAddress = true
-                receiver.bind(InetSocketAddress(local, 0))
-                receiver.soTimeout = 5_000
-
-                val payload = "softap-gate".toByteArray()
-                DatagramSocket().use { sender ->
-                    sender.send(DatagramPacket(payload, payload.size, local, receiver.localPort))
-                }
-
-                val buffer = ByteArray(64)
-                val packet = DatagramPacket(buffer, buffer.size)
-                receiver.receive(packet)
-
-                assertThat(String(packet.data, 0, packet.length)).isEqualTo("softap-gate")
-            }
-        } finally {
-            scoped.release()
-        }
-    }
-
-    // -----------------------------------------------------------------
-    // (4) + (5) libwebrtc gathers, and can select, a hotspot host candidate
-    // -----------------------------------------------------------------
-
-    /**
-     * The reviewer's primary risk. A scoped `Network` alone does not make libwebrtc's internally
-     * created UDP sockets use that interface, and its network monitor only watches
-     * internet-capable networks. If this fails, install [ScopedNetworkChangeDetector].
-     */
-    @Test
-    fun iceGatheringProducesAHotspotHostCandidate() {
-        scoped.join(ssid, passphrase)
-        val localIpv4 = requireNotNull(scoped.localIpv4())
-
-        PeerConnectionFactory.initialize(
-            PeerConnectionFactory.InitializationOptions.builder(context)
-                .createInitializationOptions(),
-        )
-        val eglBase = EglBase.create()
-        val factory =
-            PeerConnectionFactory.builder()
-                .setVideoEncoderFactory(DefaultVideoEncoderFactory(eglBase.eglBaseContext, true, true))
-                .setVideoDecoderFactory(DefaultVideoDecoderFactory(eglBase.eglBaseContext))
-                .createPeerConnectionFactory()
-
-        val candidates = mutableListOf<IceCandidate>()
-        val gathered = CountDownLatch(1)
-
-        // No ICE servers: host-only, matching what the ingest source will use.
-        val config = PeerConnection.RTCConfiguration(emptyList())
-        config.sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
-        config.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_ONCE
-
-        val peer =
-            requireNotNull(
-                factory.createPeerConnection(
-                    config,
-                    object : NoOpPeerConnectionObserver() {
-                        override fun onIceCandidate(candidate: IceCandidate) {
-                            synchronized(candidates) { candidates.add(candidate) }
-                        }
-
-                        override fun onIceGatheringChange(
-                            newState: PeerConnection.IceGatheringState,
-                        ) {
-                            if (newState == PeerConnection.IceGatheringState.COMPLETE) {
-                                gathered.countDown()
-                            }
-                        }
-                    },
-                ),
-            )
-
-        try {
-            peer.addTransceiver(org.webrtc.MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO)
-            peer.createOffer(
-                object : NoOpSdpObserver() {
-                    override fun onCreateSuccess(sdp: SessionDescription) {
-                        peer.setLocalDescription(NoOpSdpObserver(), sdp)
-                    }
-                },
-                MediaConstraints(),
-            )
-
-            assertThat(gathered.await(15, TimeUnit.SECONDS))
-                .describedAs("ICE gathering did not complete")
-                .isTrue()
-
-            val hotspotCandidates =
-                synchronized(candidates) {
-                    candidates.filter { it.sdp.contains("typ host") && it.sdp.contains(localIpv4) }
-                }
-
-            assertThat(hotspotCandidates)
-                .describedAs(
-                    "libwebrtc gathered no host candidate on the SoftAP address %s. " +
-                        "All candidates: %s. Install ScopedNetworkChangeDetector before Phase 3.",
-                    localIpv4,
-                    synchronized(candidates) { candidates.map { it.sdp } },
-                )
-                .isNotEmpty()
-        } finally {
-            peer.dispose()
-            factory.dispose()
-            eglBase.release()
-            scoped.release()
-        }
-    }
-
-    private open class NoOpPeerConnectionObserver : PeerConnection.Observer {
-        override fun onSignalingChange(state: PeerConnection.SignalingState) {}
-
-        override fun onIceConnectionChange(state: PeerConnection.IceConnectionState) {}
-
-        override fun onIceConnectionReceivingChange(receiving: Boolean) {}
-
-        override fun onIceGatheringChange(newState: PeerConnection.IceGatheringState) {}
-
-        override fun onIceCandidate(candidate: IceCandidate) {}
-
-        override fun onIceCandidatesRemoved(candidates: Array<out IceCandidate>) {}
-
-        override fun onAddStream(stream: org.webrtc.MediaStream) {}
-
-        override fun onRemoveStream(stream: org.webrtc.MediaStream) {}
-
-        override fun onDataChannel(channel: org.webrtc.DataChannel) {}
-
-        override fun onRenegotiationNeeded() {}
-
-        override fun onAddTrack(
-            receiver: org.webrtc.RtpReceiver,
-            streams: Array<out org.webrtc.MediaStream>,
-        ) {}
-    }
-
-    private open class NoOpSdpObserver : SdpObserver {
-        override fun onCreateSuccess(sdp: SessionDescription) {}
-
-        override fun onSetSuccess() {}
-
-        override fun onCreateFailure(error: String?) {}
-
-        override fun onSetFailure(error: String?) {}
-    }
-
-    private companion object {
-        const val CONNECT_TIMEOUT_MS = 5_000
-    }
-}