@mentra/acs-meeting 3.2.0-dev.120

package/ios/PhoneMicCapturer.swift

@@ -0,0 +1,64 @@
+import AVFoundation
+import Foundation
+
+/// Phone-mic uplink for ACS virtual outgoing. Taps the hardware input at
+/// whatever rate the session is already using and never switches the session
+/// into voice-chat / speaker-default, so A2DP playback can stay on the glasses.
+final class PhoneMicCapturer {
+  private let engine = AVAudioEngine()
+  private var running = false
+  var onPcm: ((Data, Int, Int) -> Void)?
+
+  func setEnabled(_ enabled: Bool) {
+    if enabled { start() } else { stop() }
+  }
+
+  private func start() {
+    guard !running else { return }
+    do {
+      let session = AVAudioSession.sharedInstance()
+      try session.setCategory(.playAndRecord, mode: .default, options: [.mixWithOthers, .allowBluetoothA2DP])
+      try session.setPreferredSampleRate(48_000)
+      try session.setActive(true, options: [])
+      let input = engine.inputNode
+      let hwFormat = input.inputFormat(forBus: 0)
+      input.removeTap(onBus: 0)
+      input.installTap(onBus: 0, bufferSize: 960, format: hwFormat) { [weak self] buffer, _ in
+        guard let self, let data = Self.pcm16(from: buffer) else { return }
+        self.onPcm?(data, Int(buffer.format.sampleRate), Int(buffer.format.channelCount))
+      }
+      try engine.start()
+      running = true
+      NSLog("ACS-SPIKE PhoneMicCapturer started")
+    } catch {
+      NSLog("ACS-SPIKE PhoneMicCapturer start failed: \(error)")
+      stop()
+    }
+  }
+
+  private func stop() {
+    engine.inputNode.removeTap(onBus: 0)
+    if engine.isRunning { engine.stop() }
+    running = false
+    NSLog("ACS-SPIKE PhoneMicCapturer stopped")
+  }
+
+  private static func pcm16(from buffer: AVAudioPCMBuffer) -> Data? {
+    let frames = Int(buffer.frameLength)
+    guard frames > 0 else { return nil }
+    let channels = Int(buffer.format.channelCount)
+    if let int16 = buffer.int16ChannelData {
+      return Data(bytes: int16[0], count: frames * channels * 2)
+    }
+    guard let floats = buffer.floatChannelData else { return nil }
+    var out = [Int16](repeating: 0, count: frames * channels)
+    for ch in 0..<channels {
+      let src = floats[ch]
+      for i in 0..<frames {
+        let clipped = max(-1.0, min(1.0, src[i]))
+        out[i * channels + ch] = Int16(clipped * Float(Int16.max))
+      }
+    }
+    return out.withUnsafeBytes { Data($0) }
+  }
+}

package/ios/PolicyKit/Package.swift

@@ -0,0 +1,17 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+  name: "AcsAudioPolicyKit",
+  platforms: [
+    .macOS(.v13),
+    .iOS(.v15),
+  ],
+  products: [
+    .library(name: "AcsAudioPolicy", targets: ["AcsAudioPolicy"]),
+  ],
+  targets: [
+    .target(name: "AcsAudioPolicy"),
+    .testTarget(name: "AcsAudioPolicyTests", dependencies: ["AcsAudioPolicy"]),
+  ]
+)

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

@@ -0,0 +1,102 @@
+public enum AudioSourceKind: String, CaseIterable, Sendable {
+  case glasses
+  case phone
+}
+
+/// Mirrors (AudioStreamType, AudioStreamState). Attached-but-STOPPED reads as none.
+public enum ActiveStreamKind: String, CaseIterable, Sendable {
+  case none
+  case virtual
+  case local
+}
+
+public enum PhysicalMuteAction: String, Sendable {
+  case mute
+  case unmute
+  case leaveAlone
+}
+
+public enum AudioSafety: String, Sendable {
+  case safe
+  case degraded
+  case unsafe
+}
+
+public struct AudioPolicyDecision: Equatable, Sendable {
+  public var glassesPcmEnabled: Bool
+  public var phonePcmEnabled: Bool
+  public var physicalMute: PhysicalMuteAction
+}
+
+public struct JoinAudioPlan: Equatable, Sendable {
+  public var armVirtual: Bool
+  public var transportMuted: Bool
+}
+
+public enum AcsAudioPolicy {
+  public static func decide(
+    desired: AudioSourceKind,
+    active: ActiveStreamKind,
+    userMuted: Bool
+  ) -> AudioPolicyDecision {
+    let glassesPcmEnabled = active == .virtual && desired == .glasses && !userMuted
+    let phonePcmEnabled = active == .virtual && desired == .phone && !userMuted
+    let physicalMute: PhysicalMuteAction
+    switch active {
+    case .virtual, .none:
+      physicalMute = .leaveAlone
+    case .local:
+      physicalMute = (desired == .phone && !userMuted) ? .unmute : .mute
+    }
+    return AudioPolicyDecision(
+      glassesPcmEnabled: glassesPcmEnabled,
+      phonePcmEnabled: phonePcmEnabled,
+      physicalMute: physicalMute
+    )
+  }
+
+  public static func planJoin(
+    desired: AudioSourceKind,
+    userMuted: Bool,
+    glassesRequiresUnmutedTransport: Bool
+  ) -> JoinAudioPlan {
+    // Phone and glasses both feed RawOutgoingAudioStream. Mute is PCM/capturer
+    // gating, never a LocalOutgoingAudioStream.
+    let armVirtual = true
+    let transportMuted: Bool
+    if desired == .glasses && glassesRequiresUnmutedTransport {
+      transportMuted = false
+    } else if desired == .phone {
+      transportMuted = false
+    } else {
+      transportMuted = userMuted
+    }
+    return JoinAudioPlan(armVirtual: armVirtual, transportMuted: transportMuted)
+  }
+
+  public static func expectedStream(_: AudioSourceKind) -> ActiveStreamKind {
+    .virtual
+  }
+
+  public static func parseSource(_ raw: String?) -> AudioSourceKind? {
+    switch raw {
+    case "glasses": return .glasses
+    case "phone": return .phone
+    default: return nil
+    }
+  }
+}
+
+public enum CallGuard {
+  public static func require<T>(_ value: T?) -> Result<T, Error> {
+    if let value {
+      return .success(value)
+    }
+    return .failure(CallMissingError())
+  }
+}
+
+public struct CallMissingError: Error, Equatable {
+  public init() {}
+  public var localizedDescription: String { "no call" }
+}

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

@@ -0,0 +1,162 @@
+public protocol AudioStreamController {
+  func readActive() -> ActiveStreamKind
+  func isPhysicallyMuted() -> Bool?
+  func setGlassesPcmEnabled(_ enabled: Bool)
+  func setPhonePcmEnabled(_ enabled: Bool)
+  func mutePhysical() -> Result<Void, Error>
+  func unmutePhysical() -> Result<Void, Error>
+  func stopActive() -> Result<Void, Error>
+}
+
+public protocol PolicyScheduler: AnyObject {
+  func schedule(delayMs: Int, task: @escaping () -> Void)
+  func cancelPending()
+}
+
+public final class AudioPolicyApplier {
+  public static let convergeDelaysMs = [50, 100, 200, 400, 800, 1600]
+
+  private let controller: AudioStreamController
+  private let scheduler: PolicyScheduler
+  private let log: (String) -> Void
+  private var generation: UInt64 = 0
+  private var lastDecision: AudioPolicyDecision?
+  private var lastSafetyValue: AudioSafety = .degraded
+
+  public init(controller: AudioStreamController, scheduler: PolicyScheduler, log: @escaping (String) -> Void = { _ in }) {
+    self.controller = controller
+    self.scheduler = scheduler
+    self.log = log
+  }
+
+  public func lastSafety() -> AudioSafety { lastSafetyValue }
+
+  @discardableResult
+  public func apply(desired: AudioSourceKind, userMuted: Bool, reason: String) -> AudioSafety {
+    generation += 1
+    scheduler.cancelPending()
+    return runApply(desired: desired, userMuted: userMuted, reason: reason, gen: generation, force: false, armConvergence: true)
+  }
+
+  public func reset() {
+    generation += 1
+    scheduler.cancelPending()
+    lastDecision = nil
+    lastSafetyValue = .degraded
+  }
+
+  @discardableResult
+  private func runApply(
+    desired: AudioSourceKind,
+    userMuted: Bool,
+    reason: String,
+    gen: UInt64,
+    force: Bool,
+    armConvergence: Bool
+  ) -> AudioSafety {
+    guard gen == generation else { return lastSafetyValue }
+    let active = controller.readActive()
+    let decision = AcsAudioPolicy.decide(desired: desired, active: active, userMuted: userMuted)
+    let outcome = applyDecision(decision, force: force)
+    guard gen == generation else { return lastSafetyValue }
+
+    let after = controller.readActive()
+    let expected = AcsAudioPolicy.expectedStream(desired)
+    let safety = safetyOf(desired: desired, active: after, outcome: outcome)
+    lastDecision = decision
+    lastSafetyValue = safety
+    log(
+      "audio policy reason=\(reason) source=\(desired) userMuted=\(userMuted) active=\(after) expected=\(expected) glassesPcm=\(decision.glassesPcmEnabled) phonePcm=\(decision.phonePcmEnabled) mute=\(decision.physicalMute) safety=\(safety)"
+    )
+
+    if after == expected {
+      scheduler.cancelPending()
+    } else if armConvergence && gen == generation {
+      self.armConvergence(desired: desired, userMuted: userMuted, gen: gen, expected: expected)
+    }
+    return lastSafetyValue
+  }
+
+  private func armConvergence(desired: AudioSourceKind, userMuted: Bool, gen: UInt64, expected: ActiveStreamKind) {
+    for (index, delayMs) in Self.convergeDelaysMs.enumerated() {
+      scheduler.schedule(delayMs: delayMs) { [weak self] in
+        guard let self, gen == self.generation else { return }
+        let isLast = index == Self.convergeDelaysMs.count - 1
+        _ = self.runApply(
+          desired: desired,
+          userMuted: userMuted,
+          reason: "converge-\(delayMs)ms",
+          gen: gen,
+          force: true,
+          armConvergence: false
+        )
+        if isLast && gen == self.generation && self.controller.readActive() != expected {
+          self.log("audio policy convergence timed out source=\(desired) expected=\(expected) holding silence")
+          self.lastSafetyValue = .degraded
+        }
+      }
+    }
+  }
+
+  private func applyDecision(_ decision: AudioPolicyDecision, force: Bool) -> EffectOutcome {
+    let previous = lastDecision
+    let skipGlassesPcm = !force && previous?.glassesPcmEnabled == decision.glassesPcmEnabled
+    let skipPhonePcm = !force && previous?.phonePcmEnabled == decision.phonePcmEnabled
+    let skipMute = !force && previous?.physicalMute == decision.physicalMute
+    if !skipGlassesPcm {
+      controller.setGlassesPcmEnabled(decision.glassesPcmEnabled)
+    }
+    if !skipPhonePcm {
+      controller.setPhonePcmEnabled(decision.phonePcmEnabled)
+    }
+    if skipMute { return .none }
+
+    switch decision.physicalMute {
+    case .leaveAlone:
+      return .none
+    case .unmute:
+      let result = controller.unmutePhysical()
+      let unmuted = controller.isPhysicallyMuted()
+      let failed = result.isFailure || unmuted == true
+      return EffectOutcome(unmuteAttempted: true, unmuteFailed: failed)
+    case .mute:
+      let result = controller.mutePhysical()
+      let muted = controller.isPhysicallyMuted()
+      let muteFailed = result.isFailure || muted == false
+      if !muteFailed { return EffectOutcome(muteAttempted: true) }
+      let stop = controller.stopActive()
+      let stopped = controller.readActive() == .none
+      return EffectOutcome(
+        muteAttempted: true,
+        muteFailed: true,
+        stopAttempted: true,
+        stopFailed: stop.isFailure || !stopped
+      )
+    }
+  }
+
+  private func safetyOf(desired: AudioSourceKind, active: ActiveStreamKind, outcome: EffectOutcome) -> AudioSafety {
+    if outcome.stopFailed { return .unsafe }
+    if outcome.stopAttempted { return .safe }
+    if outcome.unmuteFailed { return .degraded }
+    if active != AcsAudioPolicy.expectedStream(desired) { return .degraded }
+    return .safe
+  }
+}
+
+private struct EffectOutcome {
+  var muteAttempted = false
+  var muteFailed = false
+  var unmuteAttempted = false
+  var unmuteFailed = false
+  var stopAttempted = false
+  var stopFailed = false
+  static let none = EffectOutcome()
+}
+
+private extension Result {
+  var isFailure: Bool {
+    if case .failure = self { return true }
+    return false
+  }
+}

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

@@ -0,0 +1,68 @@
+import Foundation
+
+public enum SourceKind: String, Sendable {
+  case whep
+  case direct
+}
+
+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 init(url: String, kind: SourceKind = .whep) {
+    self.url = url
+    self.kind = kind
+  }
+}
+
+public protocol GlassesMediaSource: AnyObject {
+  var state: SourceState { get }
+  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 enum CapturePolicy {
+  public static func captureGlassesMic(_ source: AudioSourceKind) -> Bool {
+    source == .glasses
+  }
+}

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

@@ -0,0 +1,273 @@
+import XCTest
+@testable import AcsAudioPolicy
+
+final class AcsAudioPolicyTests: XCTestCase {
+  func testTwelveStates() {
+    let rows: [(AudioSourceKind, ActiveStreamKind, Bool, Bool, Bool, PhysicalMuteAction)] = [
+      (.glasses, .virtual, false, true, false, .leaveAlone),
+      (.glasses, .virtual, true, false, false, .leaveAlone),
+      (.glasses, .local, false, false, false, .mute),
+      (.glasses, .local, true, false, false, .mute),
+      (.glasses, .none, false, false, false, .leaveAlone),
+      (.glasses, .none, true, false, false, .leaveAlone),
+      (.phone, .local, false, false, false, .unmute),
+      (.phone, .local, true, false, false, .mute),
+      (.phone, .virtual, false, false, true, .leaveAlone),
+      (.phone, .virtual, true, false, false, .leaveAlone),
+      (.phone, .none, false, false, false, .leaveAlone),
+      (.phone, .none, true, false, false, .leaveAlone),
+    ]
+    XCTAssertEqual(rows.count, 12)
+    for row in rows {
+      let decision = AcsAudioPolicy.decide(desired: row.0, active: row.1, userMuted: row.2)
+      XCTAssertEqual(decision.glassesPcmEnabled, row.3, "\(row)")
+      XCTAssertEqual(decision.phonePcmEnabled, row.4, "\(row)")
+      XCTAssertEqual(decision.physicalMute, row.5, "\(row)")
+    }
+  }
+
+  func testCartesianInvariants() {
+    for desired in AudioSourceKind.allCases {
+      for active in ActiveStreamKind.allCases {
+        for userMuted in [false, true] {
+          let decision = AcsAudioPolicy.decide(desired: desired, active: active, userMuted: userMuted)
+          if decision.glassesPcmEnabled {
+            XCTAssertEqual(active, .virtual)
+            XCTAssertEqual(desired, .glasses)
+            XCTAssertFalse(userMuted)
+          }
+          if decision.phonePcmEnabled {
+            XCTAssertEqual(active, .virtual)
+            XCTAssertEqual(desired, .phone)
+            XCTAssertFalse(userMuted)
+          }
+          if decision.physicalMute == .unmute {
+            XCTAssertEqual(active, .local)
+            XCTAssertEqual(desired, .phone)
+            XCTAssertFalse(userMuted)
+          }
+        }
+      }
+    }
+  }
+
+  func testPlanJoinMatrix() {
+    for desired in AudioSourceKind.allCases {
+      for userMuted in [false, true] {
+        for flag in [false, true] {
+          let plan = AcsAudioPolicy.planJoin(
+            desired: desired,
+            userMuted: userMuted,
+            glassesRequiresUnmutedTransport: flag
+          )
+          XCTAssertTrue(plan.armVirtual)
+          if desired == .phone {
+            XCTAssertFalse(plan.transportMuted)
+          } else if flag {
+            XCTAssertFalse(plan.transportMuted)
+          } else {
+            XCTAssertEqual(plan.transportMuted, userMuted)
+          }
+        }
+      }
+    }
+  }
+
+  func testParseSourceAllowlist() {
+    XCTAssertEqual(AcsAudioPolicy.parseSource("glasses"), .glasses)
+    XCTAssertEqual(AcsAudioPolicy.parseSource("phone"), .phone)
+    XCTAssertNil(AcsAudioPolicy.parseSource("bluetooth"))
+    XCTAssertNil(AcsAudioPolicy.parseSource(nil))
+  }
+
+  func testCallGuardNullIsFailure() {
+    let missing: String? = nil
+    switch CallGuard.require(missing) {
+    case .success:
+      XCTFail("null call must not succeed")
+    case .failure:
+      break
+    }
+  }
+}
+
+final class FakeScheduler: PolicyScheduler {
+  struct Job {
+    var atMs: Int
+    var task: () -> Void
+  }
+
+  var nowMs = 0
+  private var jobs: [Job] = []
+
+  func schedule(delayMs: Int, task: @escaping () -> Void) {
+    jobs.append(Job(atMs: nowMs + delayMs, task: task))
+  }
+
+  func cancelPending() {
+    jobs.removeAll()
+  }
+
+  func advanceTo(_ targetMs: Int) {
+    while let nextIndex = jobs.enumerated().filter({ $0.element.atMs <= targetMs }).min(by: { $0.element.atMs < $1.element.atMs })?.offset {
+      let next = jobs.remove(at: nextIndex)
+      nowMs = next.atMs
+      next.task()
+    }
+    nowMs = targetMs
+  }
+}
+
+final class FakeController: AudioStreamController {
+  var active: ActiveStreamKind = .none
+  var physicallyMuted: Bool? = true
+  var glassesPcmEnabled = false
+  var phonePcmEnabled = false
+  var muteResult: Result<Void, Error> = .success(())
+  var unmuteResult: Result<Void, Error> = .success(())
+  var stopResult: Result<Void, Error> = .success(())
+  var muteSetsFlag = true
+  var muteCalls = 0
+  var unmuteCalls = 0
+  var stopCalls = 0
+
+  func readActive() -> ActiveStreamKind { active }
+  func isPhysicallyMuted() -> Bool? { physicallyMuted }
+  func setGlassesPcmEnabled(_ enabled: Bool) { glassesPcmEnabled = enabled }
+  func setPhonePcmEnabled(_ enabled: Bool) { phonePcmEnabled = enabled }
+  func mutePhysical() -> Result<Void, Error> {
+    muteCalls += 1
+    if case .success = muteResult, muteSetsFlag { physicallyMuted = true }
+    return muteResult
+  }
+  func unmutePhysical() -> Result<Void, Error> {
+    unmuteCalls += 1
+    if case .success = unmuteResult { physicallyMuted = false }
+    return unmuteResult
+  }
+  func stopActive() -> Result<Void, Error> {
+    stopCalls += 1
+    if case .success = stopResult { active = .none }
+    return stopResult
+  }
+}
+
+final class AudioPolicyApplierTests: XCTestCase {
+  func testNoneNoneVirtualOpensOnThirdObservation() {
+    let controller = FakeController()
+    let scheduler = FakeScheduler()
+    let applier = AudioPolicyApplier(controller: controller, scheduler: scheduler)
+    controller.active = .none
+    _ = applier.apply(desired: .glasses, userMuted: false, reason: "join")
+    XCTAssertFalse(controller.glassesPcmEnabled)
+    scheduler.advanceTo(50)
+    XCTAssertFalse(controller.glassesPcmEnabled)
+    controller.active = .virtual
+    scheduler.advanceTo(100)
+    XCTAssertTrue(controller.glassesPcmEnabled)
+    XCTAssertFalse(controller.phonePcmEnabled)
+    XCTAssertEqual(applier.lastSafety(), .safe)
+    XCTAssertEqual(controller.unmuteCalls, 0)
+  }
+
+  func testNoneNoneVirtualOpensPhonePcmOnThirdObservation() {
+    let controller = FakeController()
+    let scheduler = FakeScheduler()
+    let applier = AudioPolicyApplier(controller: controller, scheduler: scheduler)
+    controller.active = .none
+    _ = applier.apply(desired: .phone, userMuted: false, reason: "join")
+    XCTAssertFalse(controller.phonePcmEnabled)
+    scheduler.advanceTo(50)
+    XCTAssertFalse(controller.phonePcmEnabled)
+    controller.active = .virtual
+    scheduler.advanceTo(100)
+    XCTAssertTrue(controller.phonePcmEnabled)
+    XCTAssertFalse(controller.glassesPcmEnabled)
+    XCTAssertEqual(applier.lastSafety(), .safe)
+    XCTAssertEqual(controller.unmuteCalls, 0)
+  }
+
+  func testMuteFailureEscalatesToStop() {
+    let controller = FakeController()
+    let scheduler = FakeScheduler()
+    let applier = AudioPolicyApplier(controller: controller, scheduler: scheduler)
+    controller.active = .local
+    controller.physicallyMuted = false
+    controller.muteResult = .failure(CallMissingError())
+    let safety = applier.apply(desired: .phone, userMuted: true, reason: "set-muted")
+    XCTAssertEqual(controller.stopCalls, 1)
+    XCTAssertEqual(controller.active, .none)
+    XCTAssertEqual(safety, .safe)
+  }
+
+  func testApplyTwiceDoesNotRepeatUnmute() {
+    let controller = FakeController()
+    let scheduler = FakeScheduler()
+    let applier = AudioPolicyApplier(controller: controller, scheduler: scheduler)
+    controller.active = .local
+    controller.physicallyMuted = true
+    _ = applier.apply(desired: .phone, userMuted: false, reason: "join")
+    _ = applier.apply(desired: .phone, userMuted: false, reason: "call-connected")
+    XCTAssertEqual(controller.unmuteCalls, 1)
+  }
+}
+
+final class FakeGlassesMediaSource: GlassesMediaSource {
+  var started: [SourceConfig] = []
+  var restarted: [SourceConfig] = []
+  var stopped = 0
+  var pcmDeliveryEnabled = true
+  var pcmHandler: ((Data, Int, Int) -> Void)?
+  private(set) var state: SourceState = .idle
+
+  func start(config: SourceConfig) {
+    started.append(config)
+    state = .live
+  }
+
+  func restart(config: SourceConfig) {
+    restarted.append(config)
+    start(config: config)
+  }
+
+  func stop() {
+    stopped += 1
+    state = .idle
+  }
+
+  func setPcmDeliveryEnabled(_ enabled: Bool) {
+    pcmDeliveryEnabled = enabled
+  }
+
+  func emitPcm(_ data: Data) {
+    guard pcmDeliveryEnabled, state == .live else { return }
+    pcmHandler?(data, 16_000, 1)
+  }
+}
+
+final class GlassesMediaSourceTests: XCTestCase {
+  func testControllerStartRestartStopAndPcmGate() {
+    let source = FakeGlassesMediaSource()
+    var pcm: [Data] = []
+    source.pcmHandler = { data, _, _ in pcm.append(data) }
+    let controller = GlassesMediaController { source }
+    XCTAssertEqual(controller.state, .idle)
+    controller.attach(config: SourceConfig(url: "https://example.com/whep"))
+    XCTAssertEqual(source.started.map(\.url), ["https://example.com/whep"])
+    XCTAssertEqual(controller.state, .live)
+    source.emitPcm(Data([1, 2, 3, 4]))
+    XCTAssertEqual(pcm.count, 1)
+    controller.setPcmDeliveryEnabled(false)
+    source.emitPcm(Data([9, 9]))
+    XCTAssertEqual(pcm.count, 1)
+    controller.restart(config: SourceConfig(url: "https://example.com/whep-2"))
+    XCTAssertEqual(source.restarted.map(\.url), ["https://example.com/whep-2"])
+    controller.stop()
+    XCTAssertEqual(controller.state, .idle)
+  }
+
+  func testCapturePolicyMatchesAcsSource() {
+    XCTAssertTrue(CapturePolicy.captureGlassesMic(.glasses))
+    XCTAssertFalse(CapturePolicy.captureGlassesMic(.phone))
+  }
+}