@mentra/acs-meeting 3.2.0-dev.120

package/android/src/main/java/com/mentra/acsmeeting/video/Nv12FormatSpec.kt

@@ -0,0 +1,36 @@
+package com.mentra.acsmeeting.video
+
+/**
+ * The NV12 format we advertise to ACS, as plain values.
+ *
+ * Same split as [I420FormatSpec]: VideoStreamFormat is native-backed and
+ * cannot initialize under a JVM unit test. Stride2 is the interleaved UV
+ * row (`chromaW * 2`), not a third plane.
+ */
+data class Nv12FormatSpec(
+  val width: Int,
+  val height: Int,
+  val fps: Float,
+  val strideY: Int,
+  val strideUv: Int,
+) {
+  companion object {
+    fun of(width: Int = 1280, height: Int = 720, fps: Float = 15f): Nv12FormatSpec =
+      Nv12FormatSpec(
+        width = width,
+        height = height,
+        fps = fps,
+        strideY = width,
+        strideUv = Nv12Packer.strideUv(width),
+      )
+  }
+
+  fun withinAcsBounds(): Boolean {
+    val probe = I420FormatSpec.of(width, height, fps)
+    return probe.withinAcsBounds()
+  }
+
+  fun namedResolution(): AcsNamedResolution? = I420FormatSpec.of(width, height, fps).namedResolution()
+
+  fun packedSize(): Int = strideY * height + strideUv * Nv12Packer.chromaHeight(height)
+}

package/android/src/main/java/com/mentra/acsmeeting/video/Nv12Packer.kt

@@ -0,0 +1,51 @@
+package com.mentra.acsmeeting.video
+
+import java.nio.ByteBuffer
+
+/**
+ * I420 → NV12. ACS NV12 is two planes: tight Y, then interleaved UV with
+ * [strideUv] = chromaW * 2. Pure so JVM tests stay cheap.
+ */
+object Nv12Packer {
+  fun chromaHeight(height: Int): Int = I420Packer.chromaStride(height)
+
+  fun strideUv(width: Int): Int = I420Packer.chromaStride(width) * 2
+
+  fun uvSize(width: Int, height: Int): Int = strideUv(width) * chromaHeight(height)
+
+  fun packedSize(width: Int, height: Int): Int = width * height + uvSize(width, height)
+
+  fun copyY(src: ByteBuffer, strideY: Int, width: Int, height: Int, dest: ByteBuffer) {
+    I420Packer.copyPlane(src, strideY, width, height, dest)
+  }
+
+  /**
+   * Writes UVUV… rows into [dest]. Last visible chroma column is [chromaW];
+   * [strideUv] must be `chromaW * 2`.
+   */
+  fun interleaveUv(
+    u: ByteBuffer,
+    strideU: Int,
+    v: ByteBuffer,
+    strideV: Int,
+    chromaW: Int,
+    chromaH: Int,
+    dest: ByteBuffer,
+  ) {
+    val uView = u.duplicate()
+    val vView = v.duplicate()
+    val uOrigin = uView.position()
+    val vOrigin = vView.position()
+    val row = ByteArray(chromaW * 2)
+    for (r in 0 until chromaH) {
+      var di = 0
+      val uRow = uOrigin + r * strideU
+      val vRow = vOrigin + r * strideV
+      for (c in 0 until chromaW) {
+        row[di++] = uView.get(uRow + c)
+        row[di++] = vView.get(vRow + c)
+      }
+      dest.put(row)
+    }
+  }
+}

package/android/src/main/java/com/mentra/acsmeeting/video/SendGate.kt

@@ -0,0 +1,27 @@
+package com.mentra.acsmeeting.video
+
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Single in-flight send. No time gate: every unique frame reaches ACS unless
+ * the previous send is still running. [busyCount] is the only backpressure signal.
+ */
+class SendGate {
+  private val sending = AtomicBoolean(false)
+  private val busy = AtomicInteger(0)
+
+  fun tryAcquire(): Boolean {
+    if (sending.compareAndSet(false, true)) return true
+    busy.incrementAndGet()
+    return false
+  }
+
+  fun release() {
+    sending.set(false)
+  }
+
+  fun busyCount(): Int = busy.get()
+
+  fun isHeld(): Boolean = sending.get()
+}

package/android/src/main/java/com/mentra/acsmeeting/video/VideoProfile.kt

@@ -0,0 +1,57 @@
+package com.mentra.acsmeeting.video
+
+/**
+ * The one place that decides what we send ACS: geometry, rate, and bitrate
+ * ceiling. The declared format, the outgoing constraints, and the source target
+ * size all read from here so they cannot drift apart.
+ *
+ * Drift is not cosmetic. ACS runs a rate controller over a fixed bitrate
+ * budget, and its only levers are quality and dropped frames. If we advertise
+ * 30 fps and send 15, it reserves budget for frames that never arrive; if we
+ * advertise a rate we cannot sustain, it does the same. Either way the wire
+ * rate collapses while our own counters look healthy.
+ */
+data class VideoProfile(
+  val width: Int,
+  val height: Int,
+  val fps: Int,
+  val maxBitrateBps: Int,
+) {
+  fun spec(): I420FormatSpec = I420FormatSpec.of(width, height, fps.toFloat())
+
+  /** Bits available per frame at the ceiling. Below ~20 kbit the encoder starts dropping. */
+  fun bitsPerFrame(): Int = maxBitrateBps / fps
+
+  companion object {
+    /**
+     * 720p15. ACS encodes this in software on mid-range hardware (the media
+     * statistics report `codecName: "h264 sw"`), so the pixel count is a real
+     * CPU cost, not just a bitrate cost.
+     */
+    val HD = VideoProfile(width = 1280, height = 720, fps = 15, maxBitrateBps = 2_500_000)
+
+    /** Quarter the pixels of [HD]. Use when the software encoder cannot hold 15 fps at 720p. */
+    val SD = VideoProfile(width = 640, height = 360, fps = 15, maxBitrateBps = 1_000_000)
+
+    /** Investigation flip. Ships as HD. SD is 360p — a quarter of the encode work. */
+    val DEFAULT = HD
+
+    /**
+     * ACS P540. VirtualOutgoingVideoStream documents 960×540, not 540×960.
+     * 540p A/B uses this size on both WHIP and ACS.
+     */
+    val P540 = VideoProfile(width = 960, height = 540, fps = 30, maxBitrateBps = 1_500_000)
+
+    /**
+     * Same P540 geometry at 15 fps. Selectable from Mentra Call; not the default.
+     * Isolates pixel-count savings without doubling frame work versus [P540].
+     */
+    val P540_15 = VideoProfile(width = 960, height = 540, fps = 15, maxBitrateBps = 1_500_000)
+
+    fun parse(width: Int, height: Int, fps: Int, maxBitrateBps: Int): VideoProfile? {
+      if (maxBitrateBps <= 0) return null
+      I420FormatSpec.parseOrNull(width, height, fps.toFloat()) ?: return null
+      return VideoProfile(width, height, fps, maxBitrateBps)
+    }
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/RemoteRosterTest.kt

@@ -0,0 +1,40 @@
+package com.mentra.acsmeeting
+
+import com.azure.android.communication.calling.AudioStreamSampleRate
+import com.azure.android.communication.calling.ParticipantState
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class RemoteRosterTest {
+  @Test
+  fun participantStatesMapToHostVocabulary() {
+    assertThat(RemoteRoster.stateName(ParticipantState.CONNECTED)).isEqualTo("connected")
+    assertThat(RemoteRoster.stateName(ParticipantState.IN_LOBBY)).isEqualTo("lobby")
+    assertThat(RemoteRoster.stateName(ParticipantState.CONNECTING)).isEqualTo("connecting")
+    assertThat(RemoteRoster.stateName(ParticipantState.RINGING)).isEqualTo("connecting")
+    assertThat(RemoteRoster.stateName(ParticipantState.EARLY_MEDIA)).isEqualTo("connecting")
+    assertThat(RemoteRoster.stateName(ParticipantState.HOLD)).isEqualTo("hold")
+    assertThat(RemoteRoster.stateName(ParticipantState.DISCONNECTED)).isEqualTo("disconnected")
+    assertThat(RemoteRoster.stateName(ParticipantState.IDLE)).isEqualTo("idle")
+    assertThat(RemoteRoster.stateName(null)).isEqualTo("idle")
+  }
+
+  @Test
+  fun emptyRosterSnapshotsToEmptyList() {
+    val roster = RemoteRoster {}
+    assertThat(roster.snapshot()).isEmpty()
+    roster.detach()
+    assertThat(roster.snapshot()).isEmpty()
+  }
+
+  @Test
+  fun acsSampleRatesMapToHz() {
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_16000)).isEqualTo(16000)
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_22050)).isEqualTo(22050)
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_24000)).isEqualTo(24000)
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_32000)).isEqualTo(32000)
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_44100)).isEqualTo(44100)
+    assertThat(AcsMeetingSession.sampleRateHz(AudioStreamSampleRate.HZ_48000)).isEqualTo(48000)
+    assertThat(AcsMeetingSession.sampleRateHz(null)).isNull()
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/AcsAudioPolicyTest.kt

@@ -0,0 +1,204 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+
+class AcsAudioPolicyTest {
+  @Test
+  fun glassesVirtualUnmuted_sendsPcmAndLeavesPhysicalAlone() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.VIRTUAL, false, true, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun glassesVirtualMuted_gatesPcmAndLeavesPhysicalAlone() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.VIRTUAL, true, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun glassesLocalUnmuted_mutesHandsetAndGatesPcm() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.LOCAL, false, false, false, PhysicalMuteAction.MUTE)
+  }
+
+  @Test
+  fun glassesLocalMuted_mutesHandsetAndGatesPcm() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.LOCAL, true, false, false, PhysicalMuteAction.MUTE)
+  }
+
+  @Test
+  fun glassesNoneUnmuted_holdsSilence() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.NONE, false, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun glassesNoneMuted_holdsSilence() {
+    assertRow(AudioSourceKind.GLASSES, ActiveStreamKind.NONE, true, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun phoneLocalUnmuted_unmutesHandsetAndGatesPhonePcm() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.LOCAL, false, false, false, PhysicalMuteAction.UNMUTE)
+  }
+
+  @Test
+  fun phoneLocalMuted_mutesHandsetAndGatesPhonePcm() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.LOCAL, true, false, false, PhysicalMuteAction.MUTE)
+  }
+
+  @Test
+  fun phoneVirtualUnmuted_sendsPhonePcmAndLeavesPhysicalAlone() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.VIRTUAL, false, false, true, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun phoneVirtualMuted_gatesPhonePcmAndLeavesPhysicalAlone() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.VIRTUAL, true, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun phoneNoneUnmuted_holdsSilence() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.NONE, false, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun phoneNoneMuted_holdsSilence() {
+    assertRow(AudioSourceKind.PHONE, ActiveStreamKind.NONE, true, false, false, PhysicalMuteAction.LEAVE_ALONE)
+  }
+
+  @Test
+  fun cartesianProduct_neverLeaksWrongMicrophone() {
+    for (desired in AudioSourceKind.entries) {
+      for (active in ActiveStreamKind.entries) {
+        for (userMuted in listOf(false, true)) {
+          val decision = AcsAudioPolicy.decide(desired, active, userMuted)
+          if (decision.glassesPcmEnabled) {
+            assertThat(active).isEqualTo(ActiveStreamKind.VIRTUAL)
+            assertThat(desired).isEqualTo(AudioSourceKind.GLASSES)
+            assertThat(userMuted).isFalse()
+          }
+          if (decision.phonePcmEnabled) {
+            assertThat(active).isEqualTo(ActiveStreamKind.VIRTUAL)
+            assertThat(desired).isEqualTo(AudioSourceKind.PHONE)
+            assertThat(userMuted).isFalse()
+          }
+          if (decision.physicalMute == PhysicalMuteAction.UNMUTE) {
+            assertThat(active).isEqualTo(ActiveStreamKind.LOCAL)
+            assertThat(desired).isEqualTo(AudioSourceKind.PHONE)
+            assertThat(userMuted).isFalse()
+          }
+        }
+      }
+    }
+  }
+
+  @Test
+  fun planJoin_glassesRequiresUnmutedTransport_ignoresUserMute() {
+    val muted = AcsAudioPolicy.planJoin(AudioSourceKind.GLASSES, userMuted = true, glassesRequiresUnmutedTransport = true)
+    val unmuted = AcsAudioPolicy.planJoin(AudioSourceKind.GLASSES, userMuted = false, glassesRequiresUnmutedTransport = true)
+    assertThat(muted.armVirtual).isTrue()
+    assertThat(muted.transportMuted).isFalse()
+    assertThat(unmuted.armVirtual).isTrue()
+    assertThat(unmuted.transportMuted).isFalse()
+  }
+
+  @Test
+  fun planJoin_glassesWithoutUnmutedRequirement_followsUserMute() {
+    val muted = AcsAudioPolicy.planJoin(AudioSourceKind.GLASSES, userMuted = true, glassesRequiresUnmutedTransport = false)
+    val unmuted = AcsAudioPolicy.planJoin(AudioSourceKind.GLASSES, userMuted = false, glassesRequiresUnmutedTransport = false)
+    assertThat(muted.transportMuted).isTrue()
+    assertThat(unmuted.transportMuted).isFalse()
+    assertThat(muted.armVirtual).isTrue()
+  }
+
+  @Test
+  fun planJoin_phoneAlsoArmsVirtualAndKeepsTransportLive() {
+    for (glassesFlag in listOf(true, false)) {
+      val muted = AcsAudioPolicy.planJoin(AudioSourceKind.PHONE, userMuted = true, glassesRequiresUnmutedTransport = glassesFlag)
+      val unmuted = AcsAudioPolicy.planJoin(AudioSourceKind.PHONE, userMuted = false, glassesRequiresUnmutedTransport = glassesFlag)
+      assertThat(muted.armVirtual).isTrue()
+      assertThat(unmuted.armVirtual).isTrue()
+      assertThat(muted.transportMuted).isFalse()
+      assertThat(unmuted.transportMuted).isFalse()
+    }
+  }
+
+  @Test
+  fun expectedStream_isAlwaysVirtual() {
+    assertThat(AcsAudioPolicy.expectedStream(AudioSourceKind.GLASSES)).isEqualTo(ActiveStreamKind.VIRTUAL)
+    assertThat(AcsAudioPolicy.expectedStream(AudioSourceKind.PHONE)).isEqualTo(ActiveStreamKind.VIRTUAL)
+  }
+
+  @Test
+  fun parseSource_allowlistOnly() {
+    assertThat(AcsAudioPolicy.parseSource("glasses")).isEqualTo(AudioSourceKind.GLASSES)
+    assertThat(AcsAudioPolicy.parseSource("phone")).isEqualTo(AudioSourceKind.PHONE)
+    assertThat(AcsAudioPolicy.parseSource("bluetooth")).isNull()
+    assertThat(AcsAudioPolicy.parseSource("auto")).isNull()
+    assertThat(AcsAudioPolicy.parseSource(null)).isNull()
+  }
+
+  @Test
+  fun callGuard_nullIsFailureNotSuccess() {
+    val missing: Any? = null
+    val result = CallGuard.require(missing)
+    assertThat(result.isFailure).isTrue()
+    assertThat(result.exceptionOrNull()).isInstanceOf(IllegalStateException::class.java)
+    assertThat(result.exceptionOrNull()?.message).isEqualTo("no call")
+  }
+
+  @Test
+  fun callGuard_presentIsSuccess() {
+    assertThat(CallGuard.require("call").getOrThrow()).isEqualTo("call")
+  }
+
+  private fun assertRow(
+    desired: AudioSourceKind,
+    active: ActiveStreamKind,
+    userMuted: Boolean,
+    glassesPcm: Boolean,
+    phonePcm: Boolean,
+    physicalMute: PhysicalMuteAction,
+  ) {
+    val decision = AcsAudioPolicy.decide(desired, active, userMuted)
+    assertThat(decision.glassesPcmEnabled).isEqualTo(glassesPcm)
+    assertThat(decision.phonePcmEnabled).isEqualTo(phonePcm)
+    assertThat(decision.physicalMute).isEqualTo(physicalMute)
+  }
+}
+
+@RunWith(Parameterized::class)
+class AcsAudioPolicyJoinMatrixTest(
+  private val desired: AudioSourceKind,
+  private val userMuted: Boolean,
+  private val glassesRequiresUnmutedTransport: Boolean,
+) {
+  @Test
+  fun armVirtualMatchesDesired() {
+    val plan = AcsAudioPolicy.planJoin(desired, userMuted, glassesRequiresUnmutedTransport)
+    assertThat(plan.armVirtual).isTrue()
+    if (desired == AudioSourceKind.PHONE) {
+      assertThat(plan.transportMuted).isFalse()
+    } else if (glassesRequiresUnmutedTransport) {
+      assertThat(plan.transportMuted).isFalse()
+    } else {
+      assertThat(plan.transportMuted).isEqualTo(userMuted)
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    @Parameterized.Parameters(name = "{0} muted={1} glassesUnmutedTransport={2}")
+    fun data(): List<Array<Any>> {
+      val rows = mutableListOf<Array<Any>>()
+      for (desired in AudioSourceKind.entries) {
+        for (muted in listOf(false, true)) {
+          for (flag in listOf(false, true)) {
+            rows.add(arrayOf(desired, muted, flag))
+          }
+        }
+      }
+      return rows
+    }
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/AudioPolicyApplierTest.kt

@@ -0,0 +1,223 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class FakeScheduler : PolicyScheduler {
+  data class Job(val atMs: Long, val task: () -> Unit)
+
+  var nowMs = 0L
+  private val jobs = mutableListOf<Job>()
+
+  override fun schedule(delayMs: Long, task: () -> Unit) {
+    jobs.add(Job(nowMs + delayMs, task))
+  }
+
+  override fun cancelPending() {
+    jobs.clear()
+  }
+
+  fun pendingCount(): Int = jobs.size
+
+  fun advanceTo(targetMs: Long) {
+    while (true) {
+      val next = jobs.filter { it.atMs <= targetMs }.minByOrNull { it.atMs } ?: break
+      jobs.remove(next)
+      nowMs = next.atMs
+      next.task()
+    }
+    nowMs = targetMs
+  }
+}
+
+class FakeAudioStreamController : AudioStreamController {
+  var active: ActiveStreamKind = ActiveStreamKind.NONE
+  var physicallyMuted: Boolean? = true
+  var pcmEnabled: Boolean = false
+  var phonePcm: Boolean = false
+  var muteResult: Result<Unit> = Result.success(Unit)
+  var unmuteResult: Result<Unit> = Result.success(Unit)
+  var stopResult: Result<Unit> = Result.success(Unit)
+  var muteSetsFlag: Boolean = true
+  val pcmCalls = mutableListOf<Boolean>()
+  val phonePcmCalls = mutableListOf<Boolean>()
+  var muteCalls = 0
+  var unmuteCalls = 0
+  var stopCalls = 0
+
+  override fun readActive(): ActiveStreamKind = active
+
+  override fun isPhysicallyMuted(): Boolean? = physicallyMuted
+
+  override fun setGlassesPcmEnabled(enabled: Boolean) {
+    pcmEnabled = enabled
+    pcmCalls.add(enabled)
+  }
+
+  override fun setPhonePcmEnabled(enabled: Boolean) {
+    phonePcm = enabled
+    phonePcmCalls.add(enabled)
+  }
+
+  override fun mutePhysical(): Result<Unit> {
+    muteCalls += 1
+    if (muteResult.isSuccess && muteSetsFlag) physicallyMuted = true
+    return muteResult
+  }
+
+  override fun unmutePhysical(): Result<Unit> {
+    unmuteCalls += 1
+    if (unmuteResult.isSuccess) physicallyMuted = false
+    return unmuteResult
+  }
+
+  override fun stopActive(): Result<Unit> {
+    stopCalls += 1
+    if (stopResult.isSuccess) active = ActiveStreamKind.NONE
+    return stopResult
+  }
+}
+
+class AudioPolicyApplierTest {
+  private val controller = FakeAudioStreamController()
+  private val scheduler = FakeScheduler()
+  private val logs = mutableListOf<String>()
+  private val applier = AudioPolicyApplier(controller, scheduler) { logs.add(it) }
+
+  @Test
+  fun noneNoneVirtual_opensGateOnThirdObservation() {
+    controller.active = ActiveStreamKind.NONE
+    applier.apply(AudioSourceKind.GLASSES, userMuted = false, reason = "join")
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(controller.pcmCalls).containsExactly(false)
+
+    scheduler.advanceTo(50)
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(controller.pcmCalls).hasSize(2)
+
+    controller.active = ActiveStreamKind.VIRTUAL
+    scheduler.advanceTo(100)
+    assertThat(controller.pcmEnabled).isTrue()
+    assertThat(applier.lastSafety()).isEqualTo(AudioSafety.SAFE)
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+  }
+
+  @Test
+  fun noneNoneVirtual_opensPhonePcmOnThirdObservation() {
+    controller.active = ActiveStreamKind.NONE
+    applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "join")
+    assertThat(controller.phonePcm).isFalse()
+    assertThat(controller.phonePcmCalls).containsExactly(false)
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+
+    scheduler.advanceTo(50)
+    assertThat(controller.phonePcm).isFalse()
+    assertThat(controller.phonePcmCalls).hasSize(2)
+
+    controller.active = ActiveStreamKind.VIRTUAL
+    scheduler.advanceTo(100)
+    assertThat(controller.phonePcm).isTrue()
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+    assertThat(applier.lastSafety()).isEqualTo(AudioSafety.SAFE)
+  }
+
+  @Test
+  fun convergenceTimeout_holdsSilenceAndReportsDegraded() {
+    controller.active = ActiveStreamKind.NONE
+    applier.apply(AudioSourceKind.GLASSES, userMuted = false, reason = "join")
+    scheduler.advanceTo(1600)
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(applier.lastSafety()).isEqualTo(AudioSafety.DEGRADED)
+    assertThat(logs.any { it.contains("convergence timed out") }).isTrue()
+  }
+
+  @Test
+  fun muteFailureEscalatesToStop_safeWhenStopSucceeds() {
+    controller.active = ActiveStreamKind.LOCAL
+    controller.physicallyMuted = false
+    controller.muteResult = Result.failure(IllegalStateException("no call"))
+    val safety = applier.apply(AudioSourceKind.PHONE, userMuted = true, reason = "set-muted")
+    assertThat(controller.muteCalls).isEqualTo(1)
+    assertThat(controller.stopCalls).isEqualTo(1)
+    assertThat(controller.active).isEqualTo(ActiveStreamKind.NONE)
+    assertThat(safety).isEqualTo(AudioSafety.SAFE)
+  }
+
+  @Test
+  fun muteAndStopFailure_isUnsafe() {
+    controller.active = ActiveStreamKind.LOCAL
+    controller.physicallyMuted = false
+    controller.muteResult = Result.failure(IllegalStateException("mute failed"))
+    controller.stopResult = Result.failure(IllegalStateException("stop failed"))
+    val safety = applier.apply(AudioSourceKind.PHONE, userMuted = true, reason = "set-muted")
+    assertThat(controller.stopCalls).isEqualTo(1)
+    assertThat(controller.active).isEqualTo(ActiveStreamKind.LOCAL)
+    assertThat(safety).isEqualTo(AudioSafety.UNSAFE)
+  }
+
+  @Test
+  fun successfulMuteWithDisagreeingReadback_stillEscalates() {
+    controller.active = ActiveStreamKind.LOCAL
+    controller.physicallyMuted = false
+    controller.muteSetsFlag = false
+    controller.muteResult = Result.success(Unit)
+    applier.apply(AudioSourceKind.PHONE, userMuted = true, reason = "set-muted")
+    assertThat(controller.muteCalls).isEqualTo(1)
+    assertThat(controller.stopCalls).isEqualTo(1)
+    assertThat(controller.active).isEqualTo(ActiveStreamKind.NONE)
+  }
+
+  @Test
+  fun unmuteFailure_isDegradedAndNeverStops() {
+    controller.active = ActiveStreamKind.LOCAL
+    controller.physicallyMuted = true
+    controller.unmuteResult = Result.failure(IllegalStateException("unmute failed"))
+    val safety = applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "set-muted")
+    assertThat(controller.unmuteCalls).isEqualTo(1)
+    assertThat(controller.stopCalls).isEqualTo(0)
+    assertThat(safety).isEqualTo(AudioSafety.DEGRADED)
+  }
+
+  @Test
+  fun applyTwice_doesNotRepeatAcsMute() {
+    controller.active = ActiveStreamKind.LOCAL
+    controller.physicallyMuted = true
+    applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "join")
+    assertThat(controller.unmuteCalls).isEqualTo(1)
+    applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "call-connected")
+    assertThat(controller.unmuteCalls).isEqualTo(1)
+  }
+
+  @Test
+  fun applyGlassesVirtualTwice_neverUnmutesPhysical() {
+    controller.active = ActiveStreamKind.VIRTUAL
+    applier.apply(AudioSourceKind.GLASSES, userMuted = false, reason = "stream-started")
+    applier.apply(AudioSourceKind.GLASSES, userMuted = false, reason = "call-connected")
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+    assertThat(controller.muteCalls).isEqualTo(0)
+    assertThat(controller.pcmEnabled).isTrue()
+  }
+
+  @Test
+  fun staleConvergenceCannotOverwriteNewerDesiredState() {
+    controller.active = ActiveStreamKind.NONE
+    applier.apply(AudioSourceKind.GLASSES, userMuted = false, reason = "join")
+    assertThat(scheduler.pendingCount()).isGreaterThan(0)
+    applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "set-source")
+    controller.active = ActiveStreamKind.VIRTUAL
+    scheduler.advanceTo(100)
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(controller.phonePcm).isTrue()
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+  }
+
+  @Test
+  fun neverUnmutesWhileVirtualIsActive() {
+    controller.active = ActiveStreamKind.VIRTUAL
+    applier.apply(AudioSourceKind.PHONE, userMuted = false, reason = "mismatch")
+    assertThat(controller.unmuteCalls).isEqualTo(0)
+    assertThat(controller.pcmEnabled).isFalse()
+    assertThat(controller.phonePcm).isTrue()
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/CapturePolicyTest.kt

@@ -0,0 +1,12 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class CapturePolicyTest {
+  @Test
+  fun glassesCapturesMicAndPhoneDoesNot() {
+    assertThat(CapturePolicy.captureGlassesMic(AudioSourceKind.GLASSES)).isTrue()
+    assertThat(CapturePolicy.captureGlassesMic(AudioSourceKind.PHONE)).isFalse()
+  }
+}