Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

Fix media pause and resume during dictation (#957)

ALTIC9db0631a15d7
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index b8445da5..1dda788c 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -519,6 +519,7 @@ final class ASRService: ObservableObject {
private(set) var dictionaryTrainingAudioGeneration = 0
@Published private(set) var isStarting: Bool = false // Guard against re-entrant start() calls
+ private var pendingMediaCaptureSessionID: Int?
private var audioCaptureStartWaiters: [CheckedContinuation<Void, Never>] = []
var isRunningOrStarting: Bool {
self.isRunning || self.isStarting
@@ -622,6 +623,8 @@ final class ASRService: ObservableObject {
func shutdownForTermination() async {
self.isTerminating = true
+ // Give media restoration the same quit window as audio cleanup.
+ MediaPlaybackService.shared.beginShutdown()
let routeRecoveryShutdownStartedAt = Date().timeIntervalSince1970
await self.cancelAudioRouteRecoveryAndWait()
self.benchmarkLog(
@@ -665,6 +668,7 @@ final class ASRService: ObservableObject {
self.isAsrReady = false
self.isLoadingModel = false
self.isDownloadingModel = false
+ await MediaPlaybackService.shared.shutdown()
}
/// The transcription provider, selected based on the unified SpeechModel setting.
@@ -1460,10 +1464,6 @@ final class ASRService: ObservableObject {
private var isEngineTapInstalled = false
private var isRecoveringAudioRoute = false
- /// Tracks whether we paused system media for this recording session.
- /// Used to resume playback only if we were the ones who paused it.
- private var didPauseMediaForThisSession: Bool = false
-
private var audioLevelSubject = PassthroughSubject<CGFloat, Never>()
var audioLevelPublisher: AnyPublisher<CGFloat, Never> {
self.audioLevelSubject.eraseToAnyPublisher()
@@ -2106,8 +2106,6 @@ final class ASRService: ObservableObject {
// alive; startConfiguredAudioCapture reuses it for zero-stop first PCM.
let handedOffMicrophonePreview = self.handOffMicrophonePreviewToCaptureStartIfNeeded()
- // Reset media pause state for this session
- self.didPauseMediaForThisSession = false
self.audioEngineStandbyTask?.cancel()
self.audioEngineStandbyTask = nil
await self.waitForPendingAudioRouteRecoveryBeforeStart()
@@ -2139,6 +2137,15 @@ final class ASRService: ObservableObject {
self.streamingHealthLastBufferCount = 0
self.silentPCMRecoveryWatchdog = AudioCaptureIdlePolicy.SilentPCMRecoveryWatchdog()
let captureSessionID = self.benchmarkSessionID
+ // Start media work alongside microphone startup; never await it on the
+ // capture path. Track only this start so cancelling a buffer-handoff wait
+ // cannot finish the previous session's still-running transcription.
+ self.pendingMediaCaptureSessionID = captureSessionID
+ defer { self.pendingMediaCaptureSessionID = nil }
+ MediaPlaybackService.shared.recordingStarted(
+ sessionID: captureSessionID,
+ enabled: SettingsStore.shared.pauseMediaDuringTranscription
+ )
self.audioCaptureAttemptID &+= 1
var readinessAttemptID = self.audioCaptureAttemptID
self.audioCaptureReadinessGate.arm(
@@ -2359,23 +2366,6 @@ final class ASRService: ObservableObject {
)
onCaptureStarted?()
- // Pause only after capture is live so media control cannot delay the
- // first PCM packet. A quick stop while this await is in flight is
- // handled explicitly below.
- if SettingsStore.shared.pauseMediaDuringTranscription {
- let didPause = await MediaPlaybackService.shared.pauseIfPlaying()
- guard self.isRunning, self.isStoppingFinalTranscription == false else {
- if didPause {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- }
- return .started
- }
- self.didPauseMediaForThisSession = didPause
- if didPause {
- DebugLogger.shared.info("🎵 Paused system media for transcription", source: "ASRService")
- }
- }
-
// Direct capture already owns a required device-liveness listener
// on its off-main lifecycle queue.
if self.activeAudioCaptureBackend == .audioEngine,
@@ -2401,6 +2391,7 @@ final class ASRService: ObservableObject {
DebugLogger.shared.info("✅ START() completed successfully", source: "ASRService")
return .started
} catch {
+ MediaPlaybackService.shared.sessionFinished(sessionID: captureSessionID)
await self.audioCaptureReadinessGate.cancel(
sessionID: captureSessionID,
attemptID: readinessAttemptID
@@ -2426,13 +2417,6 @@ final class ASRService: ObservableObject {
DebugLogger.shared.error("Failed to start ASR session: \(error)", source: "ASRService")
}
- // Resume media if we paused it before the failure
- if self.didPauseMediaForThisSession {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- self.didPauseMediaForThisSession = false
- DebugLogger.shared.info("🎵 Resumed system media after start failure", source: "ASRService")
- }
-
guard wasCancelled == false else { return .failed }
AppServices.shared.microphonePreferenceCoordinator.markActiveSelectionUnavailable()
@@ -2563,6 +2547,9 @@ final class ASRService: ObservableObject {
func cancelPendingAudioCaptureStart(reason: String) async {
guard self.isStarting, self.isRunning == false else { return }
self.audioCaptureStartGeneration &+= 1
+ if let sessionID = self.pendingMediaCaptureSessionID {
+ MediaPlaybackService.shared.sessionFinished(sessionID: sessionID)
+ }
// A start waiting for the previous session's PCM handoff must wake to
// observe the generation change; the old stop keeps ownership of the gate.
self.recordingBufferHandoffGate.releasePendingWaiters()
@@ -2723,6 +2710,8 @@ final class ASRService: ObservableObject {
DebugLogger.shared.warning("STOP() ignored - recording buffer handoff already active", source: "ASRService")
return ""
}
+ MediaPlaybackService.shared.recordingStopped(sessionID: stoppingSessionID)
+ defer { MediaPlaybackService.shared.sessionFinished(sessionID: stoppingSessionID) }
self.isStoppingFinalTranscription = true
var completedBufferHandoff = false
defer {
@@ -2749,10 +2738,6 @@ final class ASRService: ObservableObject {
return ""
}
- // Capture media pause state before we reset it, for resuming at the end
- let shouldResumeMedia = self.didPauseMediaForThisSession
- self.didPauseMediaForThisSession = false // Reset for next session
-
DebugLogger.shared.debug("📍 Preparing final transcription", source: "ASRService")
// Freeze an exact acquisition boundary before stopping hardware. The
@@ -2813,7 +2798,6 @@ final class ASRService: ObservableObject {
self.beginStreamingDrainRecovery(sessionID: stoppingSessionID, token: bufferHandoffToken)
completedBufferHandoff = true // Recovery owns the PCM handoff until real work ends.
self.lastStopOutcome = .failed
- if shouldResumeMedia { await MediaPlaybackService.shared.resumeIfWePaused(true) }
self.benchmarkLog("stop_end result=error reason=streaming_drain_timeout")
return ""
}
@@ -2847,10 +2831,6 @@ final class ASRService: ObservableObject {
"Final ASR result | provider=\(self.transcriptionProvider.name) | samples=0 | textChars=0 | confidence=nil | reason=no_audio",
source: "ASRService"
)
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after empty audio", source: "ASRService")
- }
self.benchmarkLog("stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=no_audio")
return ""
}
@@ -2878,10 +2858,6 @@ final class ASRService: ObservableObject {
"Final ASR result | provider=\(self.transcriptionProvider.name) | samples=\(pcm.count) | textChars=0 | confidence=nil | reason=short_silence",
source: "ASRService"
)
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after silent audio", source: "ASRService")
- }
self.benchmarkLog(
"stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=short_silence"
)
@@ -2926,11 +2902,6 @@ final class ASRService: ObservableObject {
guard provider.isReady else {
DebugLogger.shared.error("Transcription provider is not ready", source: "ASRService")
self.lastStopOutcome = .failed
- // Resume media playback if we paused it
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after provider not ready", source: "ASRService")
- }
self.benchmarkLog("stop_end result=empty totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) reason=provider_not_ready")
return ""
}
@@ -3034,12 +3005,6 @@ final class ASRService: ObservableObject {
)
}
- // Resume media playback if we paused it
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after transcription", source: "ASRService")
- }
-
self.lastStopOutcome = outputText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
? .empty
: .success
@@ -3068,12 +3033,6 @@ final class ASRService: ObservableObject {
// (e.g., accidental hotkey press) and would disrupt the user's workflow.
// Errors are logged for debugging purposes.
- // Resume media playback if we paused it
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after transcription failure", source: "ASRService")
- }
-
self.benchmarkLog("stop_end result=error totalMs=\(self.elapsedMilliseconds(since: stopStartedAt)) error=\(error.localizedDescription)")
return ""
}
@@ -3285,6 +3244,8 @@ final class ASRService: ObservableObject {
guard self.isRunning else { return }
let stoppingSessionID = self.benchmarkSessionID
guard let bufferHandoffToken = self.recordingBufferHandoffGate.begin() else { return }
+ MediaPlaybackService.shared.recordingStopped(sessionID: stoppingSessionID)
+ defer { MediaPlaybackService.shared.sessionFinished(sessionID: stoppingSessionID) }
var completedBufferHandoff = false
defer {
if completedBufferHandoff == false {
@@ -3304,10 +3265,6 @@ final class ASRService: ObservableObject {
return
}
- // Capture media pause state before we reset it, for resuming at the end
- let shouldResumeMedia = self.didPauseMediaForThisSession
- self.didPauseMediaForThisSession = false // Reset for next session
-
DebugLogger.shared.info("🛑 Stopping recording - releasing audio devices", source: "ASRService")
// CRITICAL: Set isRunning to false FIRST to signal any in-flight chunks to abort early
@@ -3330,7 +3287,6 @@ final class ASRService: ObservableObject {
guard await self.drainActiveStreamingWork(sessionID: stoppingSessionID) else {
self.beginStreamingDrainRecovery(sessionID: stoppingSessionID, token: bufferHandoffToken)
completedBufferHandoff = true
- if shouldResumeMedia { await MediaPlaybackService.shared.resumeIfWePaused(true) }
return
}
@@ -3346,12 +3302,6 @@ final class ASRService: ObservableObject {
self.isProcessingChunk = false
self.skipNextChunk = false
self.refreshWordBoostStatus()
-
- // Resume media playback if we paused it
- if shouldResumeMedia {
- await MediaPlaybackService.shared.resumeIfWePaused(true)
- DebugLogger.shared.info("🎵 Resumed system media after stopping without transcription", source: "ASRService")
- }
}
private func configureSession() throws {
diff --git a/Sources/Fluid/Services/MediaPlaybackService.swift b/Sources/Fluid/Services/MediaPlaybackService.swift
index 0b99208f..1e78992d 100644
--- a/Sources/Fluid/Services/MediaPlaybackService.swift
+++ b/Sources/Fluid/Services/MediaPlaybackService.swift
@@ -1,244 +1,267 @@
import Foundation
-#if arch(arm64)
-import MediaRemoteAdapter
-#endif
-#if arch(arm64)
+/// One reconciler owns all media queries and commands. Recording events update
+/// intent synchronously; they never wait for media control or delay first PCM.
@MainActor
-protocol MediaPlaybackControlling {
- func getTrackInfo(_ onReceive: @escaping (TrackInfo?) -> Void)
- func pause()
- func play()
-}
+final class MediaPlaybackService {
+ static let shared = MediaPlaybackService(transport: MediaPlaybackProcessTransport())
-extension MediaController: MediaPlaybackControlling {}
-#endif
+ private struct Session {
+ let id: Int
+ var mayPause: Bool
+ }
-/// Service that wraps MediaRemoteAdapter's MediaController to provide
-/// controlled pause/resume functionality during transcription.
-///
-/// This service ensures we only pause media if it's currently playing,
-/// and only resume if we were the ones who paused it.
-@MainActor
-final class MediaPlaybackService {
- #if arch(arm64)
- typealias TimeoutScheduler = (
- _ delay: TimeInterval,
- _ action: @escaping @MainActor @Sendable () -> Void
- ) -> Void
+ private let transport: any MediaPlaybackTransport
+ private let settle: @Sendable () async -> Void
+ private let now: @Sendable () -> TimeInterval
+ private var session: Session?
+ private var revision: UInt64 = 0
+ private var attemptedSession: Int?
+ private var pausedTarget: MediaPlaybackSnapshot?
+ private var worker: Task<Void, Never>?
+ private var suspendedUntil: TimeInterval = 0
+ private var isShuttingDown = false
- /// The pinned adapter's two-second deadline can occupy roughly 2.1 seconds
- /// in run-loop slices. Leave additional time for process and callback delivery.
- static let nowPlayingQueryTimeoutSeconds: TimeInterval = 2.5
+ init(
+ transport: any MediaPlaybackTransport,
+ settle: @escaping @Sendable () async -> Void = {
+ try? await Task.sleep(nanoseconds: 150_000_000)
+ },
+ now: @escaping @Sendable () -> TimeInterval = { ProcessInfo.processInfo.systemUptime }
+ ) {
+ self.transport = transport
+ self.settle = settle
+ self.now = now
+ }
- private static let productionTimeoutScheduler: TimeoutScheduler = { delay, action in
- DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: action)
+ func recordingStarted(sessionID: Int, enabled: Bool) {
+ guard !self.isShuttingDown else { return }
+ self.session = enabled ? Session(id: sessionID, mayPause: true) : nil
+ self.revision &+= 1
+ self.log("recording_started session=\(sessionID) enabled=\(enabled)")
+ self.wake()
}
- static let shared = MediaPlaybackService(
- mediaController: MediaController(),
- queryTimeoutSeconds: MediaPlaybackService.nowPlayingQueryTimeoutSeconds,
- timeoutScheduler: MediaPlaybackService.productionTimeoutScheduler
- )
+ /// Prevent a slow query from issuing pause after the hotkey is released.
+ /// A previously confirmed pause stays owned until transcription finishes.
+ func recordingStopped(sessionID: Int) {
+ guard self.session?.id == sessionID else { return }
+ self.session?.mayPause = false
+ self.revision &+= 1
+ self.log("recording_stopped session=\(sessionID)")
+ self.wake()
+ }
- private let mediaController: any MediaPlaybackControlling
- private let queryTimeoutSeconds: TimeInterval
- private let timeoutScheduler: TimeoutScheduler
+ /// An older transcription finishing cannot resume a newer recording's media.
+ func sessionFinished(sessionID: Int) {
+ guard self.session?.id == sessionID else { return }
+ self.session = nil
+ self.revision &+= 1
+ self.log("session_finished session=\(sessionID)")
+ self.wake()
+ }
- /// Creates an isolated service with injectable dependencies for deterministic tests.
- init(
- mediaController: any MediaPlaybackControlling,
- queryTimeoutSeconds: TimeInterval,
- timeoutScheduler: @escaping TimeoutScheduler
- ) {
- self.mediaController = mediaController
- self.queryTimeoutSeconds = queryTimeoutSeconds
- self.timeoutScheduler = timeoutScheduler
- }
- #else
- static let shared = MediaPlaybackService()
-
- private init() {}
- #endif
-
- // MARK: - Public API
-
- #if arch(arm64)
- /// Pauses system media playback if something is currently playing.
- ///
- /// - Returns: `true` if a pause request was issued, `false` if nothing was playing or
- /// if we couldn't determine playback state. The media adapter does not acknowledge
- /// command completion.
- ///
- /// - Note: Uses a local one-shot gate to protect against `MediaRemoteAdapter`
- /// firing the `getTrackInfo` callback more than once, which would otherwise
- /// crash with `EXC_BREAKPOINT` (SIGTRAP) due to double-resume of a
- /// `CheckedContinuation`.
- func pauseIfPlaying() async -> Bool {
- return await withCheckedContinuation { continuation in
- let queryStartedAt = DispatchTime.now().uptimeNanoseconds
- let resumeLock = NSLock()
- var didResume = false
-
- @MainActor
- func elapsedMilliseconds() -> UInt64 {
- (DispatchTime.now().uptimeNanoseconds - queryStartedAt) / 1_000_000
- }
+ func beginShutdown() {
+ guard !self.isShuttingDown else { return }
+ self.isShuttingDown = true
+ self.session = nil
+ self.revision &+= 1
+ self.wake()
+ }
- @discardableResult
- @MainActor
- func resumeOnce(
- _ value: Bool,
- logDuplicate: Bool = true,
- beforeResume: () -> Void = {}
- ) -> Bool {
- var shouldResume = false
-
- resumeLock.lock()
- if !didResume {
- didResume = true
- shouldResume = true
- }
- resumeLock.unlock()
-
- guard shouldResume else {
- if logDuplicate {
- DebugLogger.shared.warning(
- """
- MediaPlaybackService: Suppressed late or duplicate media callback \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
- }
- return false
- }
+ func shutdown() async {
+ self.beginShutdown()
+ await self.waitUntilSettled()
+ }
- beforeResume()
- continuation.resume(returning: value)
- return true
- }
+ /// Also used by deterministic tests; no continuous observer or polling task.
+ func waitUntilSettled() async {
+ while let worker = self.worker {
+ await worker.value
+ }
+ }
- self.timeoutScheduler(self.queryTimeoutSeconds) {
- if resumeOnce(false, logDuplicate: false) {
- DebugLogger.shared.warning(
- """
- MediaPlaybackService: Now Playing query timed out; leaving playback unchanged \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
+ private func wake() {
+ guard self.worker == nil else { return }
+ self.worker = Task { await self.reconcile() }
+ }
+
+ private func reconcile() async {
+ while true {
+ let observedRevision = self.revision
+ if let session = self.session {
+ if session.mayPause, self.attemptedSession != session.id {
+ self.attemptedSession = session.id
+ await self.pause(sessionID: session.id)
}
+ } else if let target = self.pausedTarget {
+ await self.resume(target: target)
}
+ guard observedRevision != self.revision else {
+ self.worker = nil
+ return
+ }
+ }
+ }
- self.mediaController.getTrackInfo { [weak self] trackInfo in
- guard let self = self else {
- DebugLogger.shared.warning(
- """
- MediaPlaybackService: Service released before query completed \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
- resumeOnce(false)
- return
- }
+ private func canPause(_ sessionID: Int) -> Bool {
+ self.session?.id == sessionID && self.session?.mayPause == true
+ }
- // If no track info is available, nothing is playing
- guard let trackInfo = trackInfo else {
- DebugLogger.shared.debug(
- """
- MediaPlaybackService: No track info available, nothing to pause \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
- resumeOnce(false)
- return
- }
+ private func pause(sessionID: Int) async {
+ guard self.now() >= self.suspendedUntil else {
+ self.log("pause_suppressed session=\(sessionID) reason=player_backoff")
+ return
+ }
+ guard let before = await self.queryBeforePause(sessionID: sessionID) else { return }
+ guard self.canPause(sessionID) else {
+ self.log("pause_skipped session=\(sessionID) reason=stale_recording")
+ return
+ }
+ if let owned = self.pausedTarget, owned.matches(before), before.isPlaying == false {
+ self.log("pause_retained session=\(sessionID) reason=already_owned")
+ return
+ }
+ // A player change or manual playback invalidates our previous ownership.
+ self.pausedTarget = nil
+ guard before.isPlaying == true else {
+ self.log("pause_skipped session=\(sessionID) reason=not_known_playing")
+ return
+ }
+ let result = await self.transport.send(.pause)
+ self.logCommand(.pause, result: result, sessionID: sessionID)
+ // Even a timed-out helper might have sent its command before exiting.
+ // Observe state before deciding whether we own a pause to restore.
+ if let paused = await self.verify(target: before, playing: false, context: "pause session=\(sessionID)") {
+ self.pausedTarget = paused
+ self.log("pause_verified session=\(sessionID)")
+ } else {
+ self.backOff(context: "pause session=\(sessionID)")
+ }
+ }
- // Determine if media is currently playing
- // Use isPlaying if available, otherwise check playbackRate
- let isPlaying: Bool
- if let playing = trackInfo.payload.isPlaying {
- isPlaying = playing
- } else {
- // playbackRate of 1.0 typically means playing, 0.0 means paused
- isPlaying = (trackInfo.payload.playbackRate ?? 0.0) > 0.0
- }
+ private func queryBeforePause(sessionID: Int) async -> MediaPlaybackSnapshot? {
+ for attempt in 1...3 {
+ guard self.canPause(sessionID) else { return nil }
+ if let snapshot = await self.query(context: "before_pause session=\(sessionID) attempt=\(attempt)") {
+ return snapshot
+ }
+ guard self.canPause(sessionID) else { return nil }
+ if attempt < 3 { await self.settle() }
+ }
+ return nil
+ }
- // Log what we found
- DebugLogger.shared.debug(
- """
- MediaPlaybackService: Track info received
- - App: \(trackInfo.payload.applicationName ?? "Unknown")
- - Bundle: \(trackInfo.payload.bundleIdentifier ?? "Unknown")
- - Title: \(trackInfo.payload.title ?? "Unknown")
- - isPlaying: \(trackInfo.payload.isPlaying?.description ?? "nil")
- - playbackRate: \(trackInfo.payload.playbackRate?.description ?? "nil")
- - Determined playing: \(isPlaying)
- - elapsedMs: \(elapsedMilliseconds())
- """,
- source: "MediaPlaybackService"
- )
-
- if isPlaying {
- resumeOnce(true) {
- DebugLogger.shared.info(
- """
- MediaPlaybackService: Media is playing, sending pause command \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
- self.mediaController.pause()
- }
- } else {
- DebugLogger.shared.debug(
- """
- MediaPlaybackService: Media is not playing, no action needed \
- (elapsedMs: \(elapsedMilliseconds()))
- """,
- source: "MediaPlaybackService"
- )
- resumeOnce(false)
- }
+ private func resume(target: MediaPlaybackSnapshot) async {
+ // Retry a command only after fresh metadata confirms the same paused item.
+ // Retain ownership while a new recording may inherit the pause.
+ for attempt in 1...2 {
+ guard let before = await self.queryBeforeResume() else {
+ if self.session == nil { self.pausedTarget = nil }
+ self.log("resume_skipped reason=unknown_player")
+ return
+ }
+ guard self.session == nil else {
+ self.log("resume_skipped reason=new_recording")
+ return
+ }
+ guard target.matches(before), before.isPlaying == false else {
+ self.pausedTarget = nil
+ self.log("resume_skipped reason=player_item_or_state_changed")
+ return
+ }
+ let result = await self.transport.send(.play)
+ self.logCommand(.play, result: result, sessionID: nil)
+ if await self.verify(target: before, playing: true, context: "resume") != nil {
+ self.pausedTarget = nil
+ self.log("resume_verified")
+ return
+ }
+ guard self.session == nil else { return }
+ // Quit is best-effort within the app's overall termination deadline.
+ // Do not add another command cycle while shutdown is in progress.
+ if self.isShuttingDown || attempt == 2 {
+ self.pausedTarget = nil
+ self.backOff(context: "resume")
+ return
}
}
}
- /// Resumes media playback only if we were the ones who paused it.
- ///
- /// - Parameter wePaused: `true` if `pauseIfPlaying()` returned `true` for this session.
- func resumeIfWePaused(_ wePaused: Bool) async {
- guard wePaused else {
- DebugLogger.shared.debug(
- "MediaPlaybackService: We didn't pause media, not resuming",
- source: "MediaPlaybackService"
- )
- return
+ private func queryBeforeResume() async -> MediaPlaybackSnapshot? {
+ // Retain confirmed ownership across brief metadata outages. Retry reads,
+ // never playback commands; give up after three bounded helper calls.
+ for attempt in 1...3 {
+ guard self.session == nil else { return nil }
+ if let snapshot = await self.query(context: "before_resume attempt=\(attempt)") {
+ return snapshot
+ }
+ guard self.session == nil else { return nil }
+ if self.isShuttingDown { return nil }
+ if attempt < 3 { await self.settle() }
}
+ return nil
+ }
- DebugLogger.shared.info(
- "MediaPlaybackService: Resuming media playback (we paused it)",
- source: "MediaPlaybackService"
- )
+ private func verify(
+ target: MediaPlaybackSnapshot, playing: Bool, context: String
+ ) async -> MediaPlaybackSnapshot? {
+ // Read at most twice; never retry a playback command blindly. This checks
+ // reported state, not rendered video: Netflix can disagree with its UI.
+ for attempt in 1...2 {
+ if attempt > 1, self.isShuttingDown { break }
+ await self.settle()
+ guard let observed = await self.query(context: "verify_\(context) attempt=\(attempt)") else {
+ continue
+ }
+ guard target.matches(observed) else {
+ self.log("verification_failed context=\(context) reason=player_or_item_changed")
+ return nil
+ }
+ if observed.isPlaying == playing { return observed }
+ }
+ self.log("verification_failed context=\(context) reason=state_not_confirmed")
+ return nil
+ }
- // Use explicit play() command - never toggle
- self.mediaController.play()
+ private func query(context: String) async -> MediaPlaybackSnapshot? {
+ let started = self.now()
+ let result = await self.transport.query()
+ let elapsed = Int((self.now() - started) * 1000)
+ switch result {
+ case let .snapshot(snapshot):
+ self.log(
+ "query context=\(context) elapsedMs=\(elapsed) " +
+ "bundle=\(snapshot.bundleIdentifier) pid=\(snapshot.processID) " +
+ "playing=\(snapshot.isPlaying.map(String.init) ?? "unknown") " +
+ "hasTitle=\(snapshot.title != nil)"
+ )
+ return snapshot
+ case let .unavailable(reason):
+ self.log("query_unavailable context=\(context) elapsedMs=\(elapsed) reason=\(reason)")
+ return nil
+ }
+ }
+
+ private func backOff(context: String) {
+ // A finite cooldown limits damage from hotkey spam against an unresponsive
+ // player. The next recording after the cooldown performs a fresh query.
+ self.suspendedUntil = self.now() + 10
+ self.log("commands_suspended context=\(context) seconds=10")
}
- #else
- // Intel Mac stub - media control not available
- func pauseIfPlaying() async -> Bool {
- DebugLogger.shared.debug(
- "MediaPlaybackService: Not available on Intel Macs",
- source: "MediaPlaybackService"
- )
- return false
+
+ private func logCommand(
+ _ command: MediaPlaybackCommand, result: MediaPlaybackCommandResult, sessionID: Int?
+ ) {
+ let status: String
+ switch result {
+ case .helperCompleted: status = "helper_completed_player_unconfirmed"
+ case let .failed(reason): status = "failed:\(reason)"
+ }
+ self.log("command=\(command.rawValue) session=\(sessionID.map(String.init) ?? "none") result=\(status)")
}
- func resumeIfWePaused(_ wePaused: Bool) async {
- // No-op on Intel
+ private func log(_ message: String) {
+ DebugLogger.shared.info("MEDIA_CONTROL \(message)", source: "MediaPlaybackService")
}
- #endif
}
diff --git a/Sources/Fluid/Services/MediaPlaybackTransport.swift b/Sources/Fluid/Services/MediaPlaybackTransport.swift
new file mode 100644
index 00000000..66fe9eaa
--- /dev/null
+++ b/Sources/Fluid/Services/MediaPlaybackTransport.swift
@@ -0,0 +1,242 @@
+import Foundation
+#if arch(arm64)
+import MediaRemoteAdapter
+#endif
+
+nonisolated struct MediaPlaybackSnapshot: Equatable, Sendable {
+ let bundleIdentifier: String
+ let processID: Int32
+ let title: String?
+ let isPlaying: Bool?
+
+ // Safari exposes its WebKit media process, not a tab ID. This comparison
+ // can reject a changed player/item, but cannot prove exact-tab identity.
+ func matches(_ other: Self) -> Bool {
+ self.bundleIdentifier == other.bundleIdentifier &&
+ self.processID == other.processID && self.title == other.title
+ }
+}
+
+nonisolated enum MediaPlaybackQueryResult: Sendable {
+ case snapshot(MediaPlaybackSnapshot)
+ case unavailable(String)
+}
+
+nonisolated enum MediaPlaybackCommand: String, Sendable {
+ case pause
+ case play
+}
+
+nonisolated enum MediaPlaybackCommandResult: Sendable {
+ /// The helper exited successfully. This is NOT acknowledgement from the player.
+ case helperCompleted
+ case failed(String)
+}
+
+nonisolated protocol MediaPlaybackTransport: Sendable {
+ nonisolated func query() async -> MediaPlaybackQueryResult
+ nonisolated func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult
+}
+
+/// Uses the existing bundled bridge, but owns its process completion and output.
+/// A serial queue plus a hard process deadline prevents overlapping commands,
+/// unbounded helpers, and the adapter's exit-versus-output callback race.
+final nonisolated class MediaPlaybackProcessTransport: MediaPlaybackTransport, @unchecked Sendable {
+ private let queue = DispatchQueue(label: "media.playback.transport", qos: .utility)
+
+ func query() async -> MediaPlaybackQueryResult {
+ let result = await self.invoke("get")
+ guard result.failure == nil else { return .unavailable(result.failure ?? "helper_failed") }
+ return Self.decode(result.output)
+ }
+
+ func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult {
+ let result = await self.invoke(command.rawValue)
+ if let failure = result.failure { return .failed(failure) }
+ return .helperCompleted
+ }
+
+ static func decode(_ output: Data) -> MediaPlaybackQueryResult {
+ guard let text = String(data: output, encoding: .utf8) else {
+ return .unavailable("invalid_utf8")
+ }
+ let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+ guard !trimmed.isEmpty else { return .unavailable("empty_output") }
+ guard trimmed != "NIL", trimmed != "null" else { return .unavailable("no_media_reported") }
+ guard let object = try? JSONSerialization.jsonObject(with: output) as? [String: Any],
+ let payload = object["payload"] as? [String: Any]
+ else { return .unavailable("invalid_payload") }
+ let processID: Int32?
+ if let value = payload["PID"] as? String {
+ processID = Int32(value)
+ } else {
+ processID = (payload["PID"] as? NSNumber)?.int32Value
+ }
+ guard let bundle = payload["bundleIdentifier"] as? String, !bundle.isEmpty,
+ let processID, processID > 0
+ else { return .unavailable("missing_player_identity") }
+ let playing: Bool?
+ if let value = payload["isPlaying"] as? Bool {
+ playing = value
+ } else if let rate = payload["playbackRate"] as? Double {
+ playing = rate > 0
+ } else {
+ playing = nil
+ }
+ return .snapshot(MediaPlaybackSnapshot(
+ bundleIdentifier: bundle,
+ processID: processID,
+ title: payload["title"] as? String,
+ isPlaying: playing
+ ))
+ }
+
+ private func invoke(_ command: String) async -> MediaHelperResult {
+ await withCheckedContinuation { continuation in
+ self.queue.async {
+ continuation.resume(returning: self.run(command))
+ }
+ }
+ }
+
+ private func run(_ command: String) -> MediaHelperResult {
+ #if arch(arm64)
+ let framework = Bundle(for: MediaController.self)
+ guard let library = framework.executablePath,
+ let resourceURL = Bundle.main.url(
+ forResource: "MediaRemoteAdapter_MediaRemoteAdapter", withExtension: "bundle"
+ ),
+ let resources = Bundle(url: resourceURL),
+ let script = resources.path(forResource: "run", ofType: "pl")
+ else { return MediaHelperResult(output: Data(), failure: "bridge_resources_missing") }
+
+ // Run the shipped script unchanged. For commands, keep its run loop alive
+ // through one bounded query before exiting, as the original upstream does.
+ // The returned state is not used as command acknowledgement.
+ let wrapper = """
+ my $script = shift @ARGV;
+ my $command = $ARGV[1];
+ do $script;
+ die $@ if $@;
+ main::get() if $command eq 'pause' || $command eq 'play';
+ """
+ return MediaHelperProcess.run(arguments: ["-e", wrapper, script, library, command])
+ #else
+ return MediaHelperResult(output: Data(), failure: "unsupported_architecture")
+ #endif
+ }
+}
+
+nonisolated struct MediaHelperResult: Sendable {
+ let output: Data
+ let failure: String?
+}
+
+/// Private process plumbing; never runs on the main actor.
+nonisolated enum MediaHelperProcess {
+ static func run(arguments: [String], timeout: TimeInterval = 1.0) -> MediaHelperResult {
+ let process = Process()
+ process.executableURL = URL(fileURLWithPath: "/usr/bin/perl")
+ process.arguments = arguments
+ let output = Pipe()
+ let errors = Pipe()
+ let outputBuffer = MediaHelperBuffer(limit: 4 * 1024 * 1024)
+ let errorBuffer = MediaHelperBuffer(limit: 4096)
+ process.standardOutput = output
+ process.standardError = errors
+ output.fileHandleForReading.readabilityHandler = { handle in outputBuffer.drain(handle) }
+ errors.fileHandleForReading.readabilityHandler = { handle in errorBuffer.drain(handle) }
+ defer {
+ output.fileHandleForReading.readabilityHandler = nil
+ errors.fileHandleForReading.readabilityHandler = nil
+ try? output.fileHandleForReading.close()
+ try? errors.fileHandleForReading.close()
+ }
+ do {
+ try process.run()
+ } catch {
+ return MediaHelperResult(output: Data(), failure: "launch_failed:\(error.localizedDescription)")
+ }
+ let deadline = MediaHelperDeadline(process: process)
+ let timeoutWork = DispatchWorkItem { deadline.expire() }
+ DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + timeout, execute: timeoutWork)
+ process.waitUntilExit()
+ let timedOut = deadline.finish()
+ timeoutWork.cancel()
+ output.fileHandleForReading.readabilityHandler = nil
+ errors.fileHandleForReading.readabilityHandler = nil
+ let data = outputBuffer.finish(output.fileHandleForReading)
+ let stderr = errorBuffer.finish(errors.fileHandleForReading)
+ if timedOut { return MediaHelperResult(output: data, failure: "helper_timeout") }
+ if process.terminationStatus != 0 {
+ let message = (String(bytes: stderr.prefix(512), encoding: .utf8) ?? "invalid_utf8")
+ .replacingOccurrences(of: "\n", with: " ")
+ return MediaHelperResult(output: data, failure: "helper_exit_\(process.terminationStatus):\(message)")
+ }
+ if outputBuffer.overflowed { return MediaHelperResult(output: Data(), failure: "output_limit") }
+ return MediaHelperResult(output: data, failure: nil)
+ }
+}
+
+private final nonisolated class MediaHelperDeadline: @unchecked Sendable {
+ private let lock = NSLock()
+ private let process: Process
+ private var finished = false
+ private var expired = false
+
+ init(process: Process) { self.process = process }
+
+ func expire() {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ guard !self.finished, self.process.isRunning else { return }
+ self.expired = true
+ // This is our own one-shot Perl child, with no user state to flush.
+ kill(self.process.processIdentifier, SIGKILL)
+ }
+
+ func finish() -> Bool {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ self.finished = true
+ return self.expired
+ }
+}
+
+private final nonisolated class MediaHelperBuffer: @unchecked Sendable {
+ private let lock = NSLock()
+ private let limit: Int
+ private var data = Data()
+ private var didOverflow = false
+
+ init(limit: Int) { self.limit = limit }
+
+ var overflowed: Bool {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ return self.didOverflow
+ }
+
+ func drain(_ handle: FileHandle) {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ let chunk = handle.availableData
+ if chunk.isEmpty { handle.readabilityHandler = nil }
+ self.append(chunk)
+ }
+
+ func finish(_ handle: FileHandle) -> Data {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ while let chunk = try? handle.read(upToCount: 16_384), !chunk.isEmpty {
+ self.append(chunk)
+ }
+ return self.data
+ }
+
+ private func append(_ chunk: Data) {
+ let remaining = self.limit - self.data.count
+ if chunk.count > remaining { self.didOverflow = true }
+ self.data.append(chunk.prefix(remaining))
+ }
+}
diff --git a/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift b/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift
index 63d727e0..f799754d 100644
--- a/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift
+++ b/Tests/FluidDictationIntegrationTests/MediaPlaybackServiceTests.swift
@@ -1,215 +1,605 @@
@testable import FluidVoice_Debug
import Foundation
-#if arch(arm64)
-import MediaRemoteAdapter
-#endif
import XCTest
-#if arch(arm64)
@MainActor
final class MediaPlaybackServiceTests: XCTestCase {
- func testPlayingCallbackBeforeTimeoutRequestsPause() async throws {
- let (service, controller, scheduler) = self.makeService()
- let pauseTask = Task { await service.pauseIfPlaying() }
+ func testVerifiedPauseAndResumeAreOrdered() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.recordingStopped(sessionID: 1)
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let maxInFlight = await transport.maximumInFlight
+ XCTAssertEqual(commands, [.pause, .play])
+ XCTAssertEqual(maxInFlight, 1)
+ }
+
+ func testUnavailableOrPausedMediaNeverStartsPlayback() async {
+ for result in [MediaPlaybackQueryResult.unavailable("no_media"), self.state(false), self.state(nil)] {
+ let transport = FakeMediaPlaybackTransport([result])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertTrue(commands.isEmpty)
+ }
+ }
- await controller.waitUntilQueryRegistered()
- XCTAssertEqual(scheduler.scheduledDelays, [2.5])
- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))
+ func testInitialQueryRetriesTransientFailure() async {
+ let transport = FakeMediaPlaybackTransport([
+ .unavailable("temporary"), self.state(true), self.state(false),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause])
+ }
- let didPause = await pauseTask.value
- XCTAssertTrue(didPause)
- XCTAssertEqual(controller.pauseCallCount, 1)
+ func testInitialQueryRetriesAreBounded() async {
+ let transport = FakeMediaPlaybackTransport([
+ .unavailable("temporary"), .unavailable("temporary"), .unavailable("temporary"),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertTrue(commands.isEmpty)
+ XCTAssertEqual(count, 3)
+ }
- scheduler.advance(by: 2.5)
- XCTAssertEqual(controller.pauseCallCount, 1)
+ func testReleasedRecordingDoesNotRetryUnavailableInitialQuery() async {
+ let transport = FakeMediaPlaybackTransport([])
+ await transport.holdQuery(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForQuery(1)
+ service.recordingStopped(sessionID: 1)
+ await transport.releaseQuery(.unavailable("temporary"))
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertTrue(commands.isEmpty)
+ XCTAssertEqual(count, 1)
}
- func testCallbackAfterFormerOneSecondBoundaryStillRequestsPause() async throws {
- let (service, controller, scheduler) = self.makeService()
- let pauseTask = Task { await service.pauseIfPlaying() }
+ func testDisabledSettingDoesNoMediaIO() async {
+ let transport = FakeMediaPlaybackTransport([])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: false)
+ await service.waitUntilSettled()
+ let count = await transport.queryCount
+ XCTAssertEqual(count, 0)
+ }
- await controller.waitUntilQueryRegistered()
- XCTAssertEqual(scheduler.scheduledDelays, [MediaPlaybackService.nowPlayingQueryTimeoutSeconds])
- XCTAssertGreaterThan(MediaPlaybackService.nowPlayingQueryTimeoutSeconds, 2)
+ func testStopDuringQueryPreventsLatePause() async {
+ let transport = FakeMediaPlaybackTransport([])
+ await transport.holdQuery(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForQuery(1)
+ service.recordingStopped(sessionID: 1)
+ await transport.releaseQuery(self.state(true))
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertTrue(commands.isEmpty)
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ }
- scheduler.advance(by: 1.1)
- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))
+ func testFailedStartDuringQueryNeverPauses() async {
+ let transport = FakeMediaPlaybackTransport([])
+ await transport.holdQuery(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForQuery(1)
+ service.sessionFinished(sessionID: 1)
+ await transport.releaseQuery(self.state(true))
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertTrue(commands.isEmpty)
+ }
- let didPause = await pauseTask.value
- XCTAssertTrue(didPause)
- XCTAssertEqual(controller.pauseCallCount, 1)
+ func testFailedStartDuringPauseRestoresPlaybackOnce() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ await transport.holdCommand(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForCommand(1)
+ service.sessionFinished(sessionID: 1)
+ service.sessionFinished(sessionID: 1)
+ await transport.releaseCommand(.helperCompleted)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let maxInFlight = await transport.maximumInFlight
+ XCTAssertEqual(commands, [.pause, .play])
+ XCTAssertEqual(maxInFlight, 1)
+ }
- scheduler.advance(by: 1.4)
- XCTAssertEqual(controller.pauseCallCount, 1)
+ func testNewRecordingSupersedesPendingQueryAndOldFinish() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false)])
+ await transport.holdQuery(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForQuery(1)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ service.sessionFinished(sessionID: 1)
+ await transport.releaseQuery(self.state(true))
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertEqual(commands, [.pause])
+ XCTAssertEqual(count, 3)
}
- func testTimeoutThenLatePlayingCallbackNeverPauses() async throws {
- let (service, controller, scheduler) = self.makeService()
- let pauseTask = Task { await service.pauseIfPlaying() }
+ func testStopDuringPauseWaitsForConfirmationBeforeResume() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ await transport.holdCommand(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForCommand(1)
+ service.recordingStopped(sessionID: 1)
+ service.sessionFinished(sessionID: 1)
+ let pendingCommands = await transport.commands
+ XCTAssertEqual(pendingCommands, [.pause])
+ await transport.releaseCommand(.helperCompleted)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let maxInFlight = await transport.maximumInFlight
+ XCTAssertEqual(commands, [.pause, .play])
+ XCTAssertEqual(maxInFlight, 1)
+ }
- await controller.waitUntilQueryRegistered()
- scheduler.advance(by: 2.5)
+ func testNewRecordingDuringResumeQueryRetainsPause() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(true),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await transport.holdQuery(3)
+ service.sessionFinished(sessionID: 1)
+ await transport.waitForQuery(3)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await transport.releaseQuery(self.state(false))
+ await service.waitUntilSettled()
+ let beforeFinish = await transport.commands
+ XCTAssertEqual(beforeFinish, [.pause])
+ service.sessionFinished(sessionID: 1)
+ service.sessionFinished(sessionID: 2)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
+ }
- let didPause = await pauseTask.value
- XCTAssertFalse(didPause)
- XCTAssertEqual(controller.pauseCallCount, 0)
+ func testFailedPlayRetriesOnlyAfterConfirmingSamePausedPlayer() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),
+ self.state(false), self.state(true),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play, .play])
+ }
- controller.complete(with: try self.makeTrackInfo(isPlaying: true, playbackRate: 1))
- XCTAssertEqual(controller.pauseCallCount, 0)
+ func testFailedPlayDoesNotRetryForChangedPlayer() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),
+ self.state(false, pid: 2),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
}
- func testDuplicatePlayingCallbacksIssueOnePause() async throws {
- let (service, controller, _) = self.makeService()
- let pauseTask = Task { await service.pauseIfPlaying() }
- let playingTrack = try self.makeTrackInfo(isPlaying: true, playbackRate: 1)
+ func testFailedPlayRetryIsBounded() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),
+ self.state(false), self.state(false), self.state(false),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play, .play])
+ }
- await controller.waitUntilQueryRegistered()
- controller.complete(with: playingTrack, retainingCallback: true)
- controller.complete(with: playingTrack)
+ func testShutdownDuringPauseUsesOneVerificationPerCommand() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false),
+ ])
+ await transport.holdCommand(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForCommand(1)
+ service.beginShutdown()
+ service.beginShutdown()
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await transport.releaseCommand(.helperCompleted)
+ await service.shutdown()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertEqual(commands, [.pause, .play])
+ XCTAssertEqual(count, 4)
+ }
- let didPause = await pauseTask.value
- XCTAssertTrue(didPause)
- XCTAssertEqual(controller.pauseCallCount, 1)
+ func testNewRecordingDuringFailedPlayRetainsPause() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(false),
+ self.state(false), self.state(false), self.state(true),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await transport.holdCommand(2)
+ service.sessionFinished(sessionID: 1)
+ await transport.waitForCommand(2)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await transport.releaseCommand(.failed("timeout"))
+ await service.waitUntilSettled()
+ let beforeFinish = await transport.commands
+ XCTAssertEqual(beforeFinish, [.pause, .play])
+ service.sessionFinished(sessionID: 2)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play, .play])
}
- func testPlaybackStateResolutionDoesNotPauseFalseCasesAndUsesRateFallback() async throws {
- let nilResult = await self.pauseResult(for: nil)
- XCTAssertFalse(nilResult.didPause)
- XCTAssertEqual(nilResult.pauseCallCount, 0)
+ func testShutdownDoesNotRetryUnavailableQuery() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), .unavailable("temporary"),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await service.shutdown()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertEqual(commands, [.pause])
+ XCTAssertEqual(count, 3)
+ }
- let explicitlyPaused = await self.pauseResult(
- for: try self.makeTrackInfo(isPlaying: false, playbackRate: 1)
- )
- XCTAssertFalse(explicitlyPaused.didPause)
- XCTAssertEqual(explicitlyPaused.pauseCallCount, 0)
+ func testTransientResumeQueryFailureRetriesBeforePlaying() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), .unavailable("temporary"), self.state(false), self.state(true),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
+ }
- let zeroRate = await self.pauseResult(
- for: try self.makeTrackInfo(isPlaying: nil, playbackRate: 0)
- )
- XCTAssertFalse(zeroRate.didPause)
- XCTAssertEqual(zeroRate.pauseCallCount, 0)
+ func testResumeQueryFailureStopsAfterBoundedRetries() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), .unavailable("temporary"),
+ .unavailable("temporary"), .unavailable("temporary"),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertEqual(commands, [.pause])
+ XCTAssertEqual(count, 5)
+ }
- let positiveRate = await self.pauseResult(
- for: try self.makeTrackInfo(isPlaying: nil, playbackRate: 1)
- )
- XCTAssertTrue(positiveRate.didPause)
- XCTAssertEqual(positiveRate.pauseCallCount, 1)
+ func testResumeRetryDoesNotPlayChangedItem() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), .unavailable("temporary"), self.state(false, title: "Other"),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause])
}
- func testResumeOnlyPlaysWhenPauseOwnershipIsTrue() async {
- let (service, controller, _) = self.makeService()
+ func testNewRecordingDuringUnavailableResumeQueryRetainsPause() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(false), self.state(true),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await transport.holdQuery(3)
+ service.sessionFinished(sessionID: 1)
+ await transport.waitForQuery(3)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await transport.releaseQuery(.unavailable("temporary"))
+ await service.waitUntilSettled()
+ let beforeFinish = await transport.commands
+ XCTAssertEqual(beforeFinish, [.pause])
+ service.sessionFinished(sessionID: 2)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
+ }
- await service.resumeIfWePaused(false)
- XCTAssertEqual(controller.playCallCount, 0)
+ func testUnconfirmedPauseDoesNotResumeOrSpamCommands() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(true), self.state(true)])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ for id in 2...10 {
+ service.recordingStarted(sessionID: id, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: id)
+ }
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let count = await transport.queryCount
+ XCTAssertEqual(commands, [.pause])
+ XCTAssertEqual(count, 3)
+ }
- await service.resumeIfWePaused(true)
- XCTAssertEqual(controller.playCallCount, 1)
+ func testNewRecordingDuringPlayWaitsBeforePausingAgain() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(false), self.state(false), self.state(true), self.state(true), self.state(false),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await transport.holdCommand(2)
+ service.sessionFinished(sessionID: 1)
+ await transport.waitForCommand(2)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ service.sessionFinished(sessionID: 1)
+ await transport.releaseCommand(.helperCompleted)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ let maxInFlight = await transport.maximumInFlight
+ XCTAssertEqual(commands, [.pause, .play, .pause])
+ XCTAssertEqual(maxInFlight, 1)
}
- private func makeService() -> (
- service: MediaPlaybackService,
- controller: FakeMediaPlaybackController,
- scheduler: ManualTimeoutScheduler
- ) {
- let controller = FakeMediaPlaybackController()
- let scheduler = ManualTimeoutScheduler()
- let service = MediaPlaybackService(
- mediaController: controller,
- queryTimeoutSeconds: MediaPlaybackService.nowPlayingQueryTimeoutSeconds,
- timeoutScheduler: scheduler.schedule
- )
- return (service, controller, scheduler)
+ func testPauseRemainsOwnedUntilTranscriptionFinishes() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.recordingStopped(sessionID: 1)
+ await service.waitUntilSettled()
+ let beforeFinish = await transport.commands
+ XCTAssertEqual(beforeFinish, [.pause])
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
}
- private func pauseResult(for trackInfo: TrackInfo?) async -> (
- didPause: Bool,
- pauseCallCount: Int
- ) {
- let (service, controller, _) = self.makeService()
- let pauseTask = Task { await service.pauseIfPlaying() }
+ func testCooldownHasBoundedExit() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), self.state(true), self.state(true), self.state(true), self.state(false),
+ ])
+ let clock = MediaTestClock()
+ let service = MediaPlaybackService(transport: transport, settle: {}, now: { clock.value })
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ clock.advance(11)
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .pause])
+ }
- await controller.waitUntilQueryRegistered()
- controller.complete(with: trackInfo)
+ func testChangedPlayerOrItemAndManualPlayAreNotResumed() async {
+ for changed in [self.state(false, pid: 2), self.state(false, title: "Other"), self.state(true)] {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), changed])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause])
+ }
+ }
- return (await pauseTask.value, controller.pauseCallCount)
+ func testUnknownVerificationNeverClaimsOwnership() async {
+ let transport = FakeMediaPlaybackTransport([
+ self.state(true), .unavailable("timeout"), .unavailable("empty_output"),
+ ])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause])
}
- private func makeTrackInfo(isPlaying: Bool?, playbackRate: Double?) throws -> TrackInfo {
- var payload: [String: Any] = [:]
- if let isPlaying {
- payload["isPlaying"] = isPlaying
+ func testCommandTimeoutStillChecksForAppliedPause() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ await transport.holdCommand(1)
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await transport.waitForCommand(1)
+ await transport.releaseCommand(.failed("helper_timeout"))
+ await service.waitUntilSettled()
+ service.sessionFinished(sessionID: 1)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
+ }
+
+ func testShutdownRestoresConfirmedPauseAndRejectsNewStarts() async {
+ let transport = FakeMediaPlaybackTransport([self.state(true), self.state(false), self.state(false), self.state(true)])
+ let service = self.service(transport)
+ service.recordingStarted(sessionID: 1, enabled: true)
+ await service.waitUntilSettled()
+ await service.shutdown()
+ service.recordingStarted(sessionID: 2, enabled: true)
+ await service.waitUntilSettled()
+ let commands = await transport.commands
+ XCTAssertEqual(commands, [.pause, .play])
+ }
+
+ func testRawQueryFailuresAreDistinct() {
+ for (text, reason) in [("", "empty_output"), ("NIL\n", "no_media_reported"), ("{", "invalid_payload")] {
+ guard case let .unavailable(actual) = MediaPlaybackProcessTransport.decode(Data(text.utf8)) else {
+ return XCTFail("Expected unavailable: \(reason)")
+ }
+ XCTAssertEqual(actual, reason)
}
- if let playbackRate {
- payload["playbackRate"] = playbackRate
+ }
+
+ func testRawQueryAcceptsMissingTitleAndDoesNotOverrideExplicitPause() {
+ let text = #"{"payload":{"PID":"42","bundleIdentifier":"com.apple.WebKit.GPU","isPlaying":false,"playbackRate":1}}"#
+ guard case let .snapshot(snapshot) = MediaPlaybackProcessTransport.decode(Data(text.utf8)) else {
+ return XCTFail("Expected player state")
}
- let data = try JSONSerialization.data(withJSONObject: ["payload": payload])
- return try JSONDecoder().decode(TrackInfo.self, from: data)
+ XCTAssertEqual(snapshot.processID, 42)
+ XCTAssertNil(snapshot.title)
+ XCTAssertEqual(snapshot.isPlaying, false)
}
-}
-@MainActor
-private final class FakeMediaPlaybackController: MediaPlaybackControlling {
- private var callback: ((TrackInfo?) -> Void)?
- private var registrationWaiters: [CheckedContinuation<Void, Never>] = []
- private(set) var pauseCallCount = 0
- private(set) var playCallCount = 0
+ func testProcessDrainsBothPipesBeforeCompletion() async {
+ let result = await Task.detached {
+ MediaHelperProcess.run(arguments: ["-e", "print 'x' x 200000; print STDERR 'y' x 200000;"])
+ }.value
+ XCTAssertNil(result.failure)
+ XCTAssertEqual(result.output.count, 200_000)
+ }
- func getTrackInfo(_ onReceive: @escaping (TrackInfo?) -> Void) {
- self.callback = onReceive
- let waiters = self.registrationWaiters
- self.registrationWaiters.removeAll()
- waiters.forEach { $0.resume() }
+ func testDefaultProcessTimeoutIsOneSecond() async {
+ let started = ProcessInfo.processInfo.systemUptime
+ let result = await Task.detached {
+ MediaHelperProcess.run(arguments: ["-e", "sleep 10"])
+ }.value
+ XCTAssertEqual(result.failure, "helper_timeout")
+ XCTAssertLessThan(ProcessInfo.processInfo.systemUptime - started, 2.0)
}
- func pause() {
- self.pauseCallCount += 1
+ func testProcessTimeoutTerminatesHelper() async {
+ let result = await Task.detached {
+ MediaHelperProcess.run(arguments: ["-e", "sleep 10;"], timeout: 0.1)
+ }.value
+ XCTAssertEqual(result.failure, "helper_timeout")
}
- func play() {
- self.playCallCount += 1
+ func testProcessOutputIsBounded() async {
+ let result = await Task.detached {
+ MediaHelperProcess.run(arguments: ["-e", "print 'x' x 5000000;"])
+ }.value
+ XCTAssertEqual(result.failure, "output_limit")
+ XCTAssertTrue(result.output.isEmpty)
}
- func waitUntilQueryRegistered() async {
- guard self.callback == nil else { return }
- await withCheckedContinuation { continuation in
- self.registrationWaiters.append(continuation)
+ private func service(_ transport: FakeMediaPlaybackTransport) -> MediaPlaybackService {
+ MediaPlaybackService(transport: transport, settle: {}, now: { 0 })
+ }
+
+ private func state(_ playing: Bool?, pid: Int32 = 1, title: String = "Netflix") -> MediaPlaybackQueryResult {
+ .snapshot(MediaPlaybackSnapshot(bundleIdentifier: "com.apple.WebKit.GPU", processID: pid, title: title, isPlaying: playing))
+ }
+}
+
+private actor FakeMediaPlaybackTransport: MediaPlaybackTransport {
+ private var results: [MediaPlaybackQueryResult]
+ private var heldQueryIndex: Int?
+ private var heldCommandIndex: Int?
+ private var queryContinuation: CheckedContinuation<MediaPlaybackQueryResult, Never>?
+ private var commandContinuation: CheckedContinuation<MediaPlaybackCommandResult, Never>?
+ private var queryWaiter: (Int, CheckedContinuation<Void, Never>)?
+ private var commandWaiter: (Int, CheckedContinuation<Void, Never>)?
+ private var inFlight = 0
+ private(set) var maximumInFlight = 0
+ private(set) var queryCount = 0
+ private(set) var commands: [MediaPlaybackCommand] = []
+
+ init(_ results: [MediaPlaybackQueryResult]) { self.results = results }
+
+ func query() async -> MediaPlaybackQueryResult {
+ self.inFlight += 1
+ self.maximumInFlight = max(self.maximumInFlight, self.inFlight)
+ defer { self.inFlight -= 1 }
+ self.queryCount += 1
+ if let (count, continuation) = self.queryWaiter, self.queryCount >= count {
+ self.queryWaiter = nil
+ continuation.resume()
+ }
+ if self.queryCount == self.heldQueryIndex {
+ return await withCheckedContinuation { self.queryContinuation = $0 }
}
+ return self.results.isEmpty ? .unavailable("exhausted") : self.results.removeFirst()
}
- func complete(with trackInfo: TrackInfo?, retainingCallback: Bool = false) {
- let callback = self.callback
- if !retainingCallback {
- self.callback = nil
+ func send(_ command: MediaPlaybackCommand) async -> MediaPlaybackCommandResult {
+ self.inFlight += 1
+ self.maximumInFlight = max(self.maximumInFlight, self.inFlight)
+ defer { self.inFlight -= 1 }
+ self.commands.append(command)
+ if let (count, continuation) = self.commandWaiter, self.commands.count >= count {
+ self.commandWaiter = nil
+ continuation.resume()
}
- callback?(trackInfo)
+ if self.commands.count == self.heldCommandIndex {
+ return await withCheckedContinuation { self.commandContinuation = $0 }
+ }
+ return .helperCompleted
}
-}
-@MainActor
-private final class ManualTimeoutScheduler {
- private struct ScheduledAction {
- let deadline: TimeInterval
- let action: @MainActor @Sendable () -> Void
+ func holdQuery(_ index: Int) { self.heldQueryIndex = index }
+ func holdCommand(_ index: Int) { self.heldCommandIndex = index }
+ func releaseQuery(_ result: MediaPlaybackQueryResult) {
+ self.queryContinuation?.resume(returning: result)
+ self.queryContinuation = nil
}
- private var currentTime: TimeInterval = 0
- private var scheduledActions: [ScheduledAction] = []
+ func releaseCommand(_ result: MediaPlaybackCommandResult) {
+ self.commandContinuation?.resume(returning: result)
+ self.commandContinuation = nil
+ }
+
+ func waitForQuery(_ count: Int) async {
+ guard self.queryCount < count else { return }
+ await withCheckedContinuation { self.queryWaiter = (count, $0) }
+ }
- var scheduledDelays: [TimeInterval] {
- self.scheduledActions.map(\.deadline)
+ func waitForCommand(_ count: Int) async {
+ guard self.commands.count < count else { return }
+ await withCheckedContinuation { self.commandWaiter = (count, $0) }
}
+}
+
+private final nonisolated class MediaTestClock: @unchecked Sendable {
+ private let lock = NSLock()
+ private var time: TimeInterval = 0
- func schedule(after delay: TimeInterval, action: @escaping @MainActor @Sendable () -> Void) {
- self.scheduledActions.append(
- ScheduledAction(deadline: self.currentTime + delay, action: action)
- )
+ var value: TimeInterval {
+ self.lock.lock()
+ defer { self.lock.unlock() }
+ return self.time
}
- func advance(by interval: TimeInterval) {
- self.currentTime += interval
- let readyActions = self.scheduledActions.filter { $0.deadline <= self.currentTime }
- self.scheduledActions.removeAll { $0.deadline <= self.currentTime }
- readyActions.forEach { $0.action() }
+ func advance(_ seconds: TimeInterval) {
+ self.lock.lock()
+ self.time += seconds
+ self.lock.unlock()
}
}
-#endif