Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

fix: serialize audio device recovery and label preset copies

louisfa4dbb0aa7b3
diff --git a/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx b/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx
index 86d623ad2..6939f3563 100644
--- a/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx
+++ b/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx
@@ -1287,7 +1287,7 @@ const AISection = ({
<ArrowLeft className="w-4 h-4" /> Back
</Button>
<h1 className="text-xl font-semibold">
- {preset ? ui("Update preset") : ui("Create preset")}
+ {isDuplicating ? ui("Duplicate preset") : preset ? ui("Update preset") : ui("Create preset")}
</h1>
</div>
@@ -1952,7 +1952,7 @@ const AISection = ({
) : (
<AlertCircle className="w-4 h-4" />
)}
- {preset ? ui("Update preset") : ui("Create preset")}
+ {isDuplicating ? ui("Create copy") : preset ? ui("Update preset") : ui("Create preset")}
</Button>
</span>
</TooltipTrigger>
diff --git a/crates/screenpipe-audio/src/audio_manager/manager.rs b/crates/screenpipe-audio/src/audio_manager/manager.rs
index 74d596424..81b8945f5 100644
--- a/crates/screenpipe-audio/src/audio_manager/manager.rs
+++ b/crates/screenpipe-audio/src/audio_manager/manager.rs
@@ -721,12 +721,16 @@ impl AudioManager {
// Stop producers FIRST: abort per-device recording tasks and the OS audio streams.
// This must happen before killing the consumer so any audio already queued in the
// audio channel (including the final 30s flush) can still be drained.
- for pair in self.recording_handles.iter() {
- let handle = pair.value();
+ let device_stop_result = self.device_manager.stop_all_devices().await;
+ let handles: Vec<_> = self
+ .recording_handles
+ .iter()
+ .map(|p| p.value().clone())
+ .collect();
+ self.recording_handles.clear();
+ for handle in handles {
handle.lock().await.abort();
}
- self.recording_handles.clear();
- self.device_manager.stop_all_devices().await?;
// Drain the channel: wait until the pipeline handler has consumed all queued chunks
// (or a hard timeout expires). The early persist — file write + DB insert — happens
@@ -760,7 +764,7 @@ impl AudioManager {
}
info!("audio manager stopped");
- Ok(())
+ device_stop_result
}
pub async fn stop(&self) -> Result<()> {
@@ -794,26 +798,27 @@ impl AudioManager {
/// Idempotent — safe to call on already-stopped devices.
/// Used by device monitor for force-cycling devices after sleep/wake.
pub async fn stop_device_recording(&self, device: &AudioDevice) -> Result<()> {
+ let manager = self.clone();
+ let target = device.clone();
+ self.device_manager
+ .run_device_operation(device, async move {
+ manager.stop_device_recording_inner(&target).await
+ })
+ .await
+ }
+
+ async fn stop_device_recording_inner(&self, device: &AudioDevice) -> Result<()> {
// Signal the recording loop to stop BEFORE aborting the handle,
// so it exits cleanly without triggering "stream dead" warnings.
if let Some(is_running) = self.device_manager.is_running_mut(device) {
is_running.store(false, std::sync::atomic::Ordering::Relaxed);
}
- // Ignore "already stopped" errors
- if let Err(e) = self.device_manager.stop_device(device).await {
- let msg = e.to_string();
- if !msg.contains("already stopped") && !msg.contains("not running") {
- return Err(e);
- }
- }
-
- if let Some(pair) = self.recording_handles.get(device) {
- let handle = pair.value();
+ let result = self.device_manager.stop_device(device).await;
+ if let Some((_, handle)) = self.recording_handles.remove(device) {
handle.lock().await.abort();
}
-
- self.recording_handles.remove(device);
+ result?;
Ok(())
}
@@ -827,7 +832,7 @@ impl AudioManager {
}
/// Temporarily pause a device without changing the configured device list.
- /// Idempotent — safe to call if already paused. Never errors.
+ /// Idempotent — safe to call if already paused. Reports native teardown failures.
pub async fn pause_device(&self, device_name: &str) -> Result<()> {
self.user_enabled_devices.write().await.remove(device_name);
// Mark as disabled FIRST so no monitor path can race and restart it
@@ -836,10 +841,8 @@ impl AudioManager {
.await
.insert(device_name.to_string());
- // Best-effort stop — ignore all errors (already stopped, not found, etc.)
- if let Ok(device) = parse_audio_device(device_name) {
- let _ = self.stop_device_recording(&device).await;
- }
+ let device = parse_audio_device(device_name)?;
+ self.stop_device_recording(&device).await?;
info!("user paused audio device: {}", device_name);
Ok(())
}
@@ -905,6 +908,20 @@ impl AudioManager {
}
pub async fn start_device(&self, device: &AudioDevice) -> Result<()> {
+ let manager = self.clone();
+ let target = device.clone();
+ self.device_manager
+ .run_device_operation(
+ device,
+ async move { manager.start_device_inner(&target).await },
+ )
+ .await
+ }
+
+ async fn start_device_inner(&self, device: &AudioDevice) -> Result<()> {
+ if self.status().await != AudioManagerStatus::Running {
+ return Err(anyhow!("audio manager is stopped"));
+ }
if self.options.read().await.is_disabled {
debug!(
"skipping start of audio device because audio capture is disabled: {}",
@@ -1013,11 +1030,22 @@ impl AudioManager {
}
}
+ if self.status().await != AudioManagerStatus::Running
+ || self
+ .user_disabled_devices
+ .read()
+ .await
+ .contains(&device.to_string())
+ {
+ self.stop_device_recording_inner(device).await?;
+ return Ok(());
+ }
+
// The meeting may end while the OS backend is opening the stream. The
// pre-start gate cannot close that race, and the monitor cannot see the
// stream until its recording handle is registered.
if self.meetings_only_capture_waiting().await {
- self.stop_device_recording(device).await?;
+ self.stop_device_recording_inner(device).await?;
debug!(
"stopped newly-opened audio device after meeting ended during startup: {}",
device
@@ -1028,7 +1056,7 @@ impl AudioManager {
// Close the race where meeting detection changes while the backend is
// opening a normal stream. Session streams never pass through here.
if self.meeting_piggyback_owns_normal_capture().await {
- self.stop_device_recording(device).await?;
+ self.stop_device_recording_inner(device).await?;
info!(
"smart recording engaged mid-open — stopped normal audio device: {}",
device
@@ -1041,7 +1069,7 @@ impl AudioManager {
// cannot see this stream until its recording handle is registered.
#[cfg(target_os = "macos")]
if screenpipe_config::should_pause_audio_for_lock() {
- self.stop_device_recording(device).await?;
+ self.stop_device_recording_inner(device).await?;
debug!(
"stopped newly-opened audio device after screen locked during startup: {}",
device
@@ -1078,6 +1106,23 @@ impl AudioManager {
device: &AudioDevice,
tap_pids: Option<Vec<i32>>,
) -> Result<()> {
+ let manager = self.clone();
+ let target = device.clone();
+ self.device_manager
+ .run_device_operation(device, async move {
+ manager.start_session_device_inner(&target, tap_pids).await
+ })
+ .await
+ }
+
+ async fn start_session_device_inner(
+ &self,
+ device: &AudioDevice,
+ tap_pids: Option<Vec<i32>>,
+ ) -> Result<()> {
+ if self.status().await != AudioManagerStatus::Running {
+ return Err(anyhow!("audio manager is stopped"));
+ }
if self.options.read().await.is_disabled {
return Err(anyhow!("audio capture is disabled"));
}
@@ -1139,6 +1184,21 @@ impl AudioManager {
}
}
+ if self.status().await != AudioManagerStatus::Running
+ || self
+ .user_disabled_devices
+ .read()
+ .await
+ .contains(&device.to_string())
+ {
+ self.session_devices
+ .write()
+ .unwrap()
+ .remove(&device.to_string());
+ self.stop_device_recording_inner(device).await?;
+ return Err(anyhow!("device {} capture was stopped during startup", device));
+ }
+
// The meeting can end while the backend is opening the stream. Remove
// session ownership before stopping so a racing callback cannot bypass
// the persistence gate after the edge.
@@ -1151,7 +1211,7 @@ impl AudioManager {
.write()
.unwrap()
.remove(&device.to_string());
- self.stop_device_recording(device).await?;
+ self.stop_device_recording_inner(device).await?;
debug!(
"stopped newly-opened meeting-session audio device after the meeting ended during startup: {}",
device
@@ -1167,7 +1227,7 @@ impl AudioManager {
.write()
.unwrap()
.remove(&device.to_string());
- self.stop_device_recording(device).await?;
+ self.stop_device_recording_inner(device).await?;
debug!(
"stopped newly-opened meeting-session audio device after screen locked during startup: {}",
device
@@ -1198,11 +1258,18 @@ impl AudioManager {
/// Tear down a meeting-session stream. Never touches `enabled_devices`.
pub async fn stop_session_device(&self, device: &AudioDevice) -> Result<()> {
- self.session_devices
- .write()
- .unwrap()
- .remove(&device.to_string());
- self.stop_device_recording(device).await
+ let manager = self.clone();
+ let target = device.clone();
+ self.device_manager
+ .run_device_operation(device, async move {
+ manager
+ .session_devices
+ .write()
+ .unwrap()
+ .remove(&target.to_string());
+ manager.stop_device_recording_inner(&target).await
+ })
+ .await
}
/// Snapshot of the currently-registered meeting-session device names.
@@ -1909,22 +1976,14 @@ impl AudioManager {
output_devices.len()
);
+ // Publish the gate before teardown so recovery cannot reopen an output.
+ *self.drm_stopped_devices.write().await = output_devices.clone();
for device in &output_devices {
- // Stop the underlying stream
- if let Err(e) = self.device_manager.stop_device(device).await {
+ if let Err(e) = self.stop_device_recording(device).await {
warn!("DRM: failed to stop audio device {}: {:?}", device, e);
}
-
- // Abort the recording task
- if let Some(pair) = self.recording_handles.get(device) {
- pair.value().lock().await.abort();
- }
- self.recording_handles.remove(device);
}
- // Store stopped devices for later restart
- *self.drm_stopped_devices.write().await = output_devices;
-
Ok(())
}
@@ -2409,14 +2468,7 @@ impl AudioManager {
Err(_) => return Err(anyhow!("Device {} not found", device_name)),
};
- // Remove from recording handles
- if let Some((_, handle)) = self.recording_handles.remove(&device) {
- // Abort the handle if somehow still running
- handle.lock().await.abort();
- }
-
- // Stop the device in device manager (clears streams and states)
- let _ = self.device_manager.stop_device(&device).await;
+ self.stop_device_recording(&device).await?;
debug!("cleaned up stale device {} for restart", device_name);
diff --git a/crates/screenpipe-audio/src/core/stream.rs b/crates/screenpipe-audio/src/core/stream.rs
index 16266de88..84f875b85 100644
--- a/crates/screenpipe-audio/src/core/stream.rs
+++ b/crates/screenpipe-audio/src/core/stream.rs
@@ -610,54 +610,47 @@ impl AudioStream {
}
pub async fn stop(&self) -> Result<()> {
+ self.stop_with_timeout(std::time::Duration::from_secs(3))
+ .await
+ }
+
+ async fn stop_with_timeout(&self, timeout: std::time::Duration) -> Result<()> {
self.is_disconnected.store(true, Ordering::Relaxed);
+ let deadline = tokio::time::Instant::now() + timeout;
- // PulseAudio path: the capture thread checks is_disconnected and exits
- // on its own — no stream_control message needed.
#[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]
{
- // Sources without a cpal control channel (e.g. `from_wav`,
- // `from_sender_for_test`) drop the receiver, so the send/recv
- // here will error. That's expected — `is_disconnected` already
- // signals the playback task to exit. Don't propagate this error.
+ // Queue teardown without an unbounded acknowledgement wait. The
+ // worker handle below proves native pause/drop actually completed.
let (control, rx) = StreamControl::stop(StopMode::Immediate);
if self.stream_control.send(control).is_ok() {
- let _ = rx.await;
+ tokio::time::timeout_at(deadline, rx)
+ .await
+ .map_err(|_| {
+ anyhow::anyhow!("audio device {} teardown timed out", self.device)
+ })?
+ .ok();
}
}
- if let Some(thread_arc) = self.stream_thread.as_ref() {
- let thread_arc_clone = thread_arc.clone();
- tokio::task::spawn_blocking(move || {
- let mut thread_guard = thread_arc_clone.blocking_lock();
- if let Some(join_handle) = thread_guard.take() {
- // Wait up to 3s for the playback task to exit naturally so cpal
- // stream.pause()+drop() can run before the stream resources go
- // away — aborting mid-callback is what races the CoreAudio IO
- // thread into UAF (issue #3261). If the task is wedged in cpal
- // / CoreAudio though, fall back to abort() so stop() can't hang
- // forever on quit/device-switch.
- let deadline =
- std::time::Instant::now() + std::time::Duration::from_secs(3);
- while !join_handle.is_finished()
- && std::time::Instant::now() < deadline
- {
- std::thread::sleep(std::time::Duration::from_millis(10));
- }
- if !join_handle.is_finished() {
- // Fully-qualified — `use tracing::{error, warn}` above
- // is cfg-gated to non-pulseaudio builds, so on linux+
- // pulseaudio CI (Release CLI) `warn!` is out of scope.
- tracing::warn!(
- "audio stream thread did not exit within 3s; aborting (potential cpal/CoreAudio wedge)"
- );
- join_handle.abort();
- }
- }
- })
- .await?;
+ if let Some(thread) = self.stream_thread.as_ref() {
+ let mut worker = tokio::time::timeout_at(deadline, thread.lock())
+ .await
+ .map_err(|_| {
+ anyhow::anyhow!("audio device {} teardown is still pending", self.device)
+ })?;
+ if let Some(handle) = worker.as_mut() {
+ // Poll by mutable reference: timing out must retain ownership.
+ // Aborting spawn_blocking does not cancel native CoreAudio work.
+ let result = tokio::time::timeout_at(deadline, handle)
+ .await
+ .map_err(|_| {
+ anyhow::anyhow!("audio device {} worker did not exit", self.device)
+ })?;
+ worker.take();
+ result?;
+ }
}
-
Ok(())
}
@@ -1044,6 +1037,56 @@ mod from_wav_tests {
use super::*;
use std::time::Duration;
+ #[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]
+ #[tokio::test]
+ async fn teardown_timeout_retains_native_worker_and_allows_later_cleanup() {
+ let device = Arc::new(AudioDevice::new(
+ "test mic".into(),
+ super::super::device::DeviceType::Input,
+ ));
+ let (mut stream, _tx) = AudioStream::from_sender_for_test(device, 48_000, 1);
+ let (control_tx, control_rx) = mpsc::channel();
+ let (release_tx, release_rx) = mpsc::channel();
+ stream.stream_control = control_tx;
+ stream.stream_thread = Some(Arc::new(tokio::sync::Mutex::new(Some(
+ tokio::task::spawn_blocking(move || {
+ release_rx.recv().unwrap();
+ if let Ok(StreamControl::Stop {
+ _response: response,
+ ..
+ }) = control_rx.recv()
+ {
+ response.send(()).ok();
+ }
+ }),
+ ))));
+ let error = tokio::time::timeout(
+ Duration::from_secs(1),
+ stream.stop_with_timeout(Duration::from_millis(50)),
+ )
+ .await
+ .expect("stop must be bounded")
+ .unwrap_err();
+ assert!(error.to_string().contains("teardown timed out"));
+ assert!(stream.is_disconnected());
+ assert!(stream
+ .stream_thread
+ .as_ref()
+ .unwrap()
+ .lock()
+ .await
+ .is_some());
+ release_tx.send(()).unwrap();
+ stream.stop().await.unwrap();
+ assert!(stream
+ .stream_thread
+ .as_ref()
+ .unwrap()
+ .lock()
+ .await
+ .is_none());
+ }
+
#[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]
#[test]
fn detects_windows_mic_access_denied_without_hiding_other_failures() {
diff --git a/crates/screenpipe-audio/src/device/device_manager.rs b/crates/screenpipe-audio/src/device/device_manager.rs
index ccf4f1755..ea471ab2d 100644
--- a/crates/screenpipe-audio/src/device/device_manager.rs
+++ b/crates/screenpipe-audio/src/device/device_manager.rs
@@ -12,6 +12,8 @@ use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
+use std::{future::Future, time::Duration};
+use tokio::sync::Mutex;
use tracing::{debug, info, warn};
#[derive(Clone, Copy)]
@@ -27,6 +29,7 @@ impl DeviceResolution {
}
pub struct DeviceManager {
+ operations: DashMap<AudioDevice, Arc<Mutex<()>>>,
streams: Arc<DashMap<AudioDevice, Arc<AudioStream>>>,
states: Arc<DashMap<AudioDevice, Arc<AtomicBool>>>,
/// When true, System Audio (output) uses the CoreAudio Process Tap path
@@ -54,6 +57,7 @@ impl DeviceManager {
let states = Arc::new(DashMap::new());
Ok(Self {
+ operations: DashMap::new(),
streams,
states,
use_coreaudio_tap: AtomicBool::new(use_coreaudio_tap),
@@ -63,6 +67,34 @@ impl DeviceManager {
})
}
+ /// Serialize the complete stream/recording-handle transition. Once admitted,
+ /// an operation owns its guard in a task so a cancelled API request or monitor
+ /// cannot release the device while native startup/teardown is still running.
+ pub(crate) async fn run_device_operation<F>(
+ &self,
+ device: &AudioDevice,
+ operation: F,
+ ) -> Result<()>
+ where
+ F: Future<Output = Result<()>> + Send + 'static,
+ {
+ let lock = self.operations.entry(device.clone()).or_default().clone();
+ let guard = tokio::time::timeout(Duration::from_secs(10), lock.lock_owned())
+ .await
+ .map_err(|_| anyhow!("device {device} is still completing a previous operation"))?;
+ let task = tokio::spawn(async move {
+ let _guard = guard;
+ operation.await
+ });
+ tokio::time::timeout(Duration::from_secs(10), task)
+ .await
+ .map_err(|_| {
+ anyhow!(
+ "device {device} operation timed out; native teardown/startup is still owned"
+ )
+ })??
+ }
+
pub fn configure_backend_flags(
&self,
use_coreaudio_tap: bool,
@@ -155,6 +187,17 @@ impl DeviceManager {
tap_pids: Option<Vec<i32>>,
resolution: DeviceResolution,
) -> Result<()> {
+ // A published stream owns the native device even before its recording
+ // loop has set is_running. Never replace that stream during startup.
+ if let Some(stream) = self.stream(device) {
+ if !stream.is_disconnected() {
+ return Err(anyhow!("Device {} already running.", device));
+ }
+ // A timed-out stop retains its worker. Retry teardown before opening
+ // a replacement; abort() cannot stop a running spawn_blocking task.
+ self.stop_device(device).await?;
+ }
+
// Generic starts validate against the inventory. Meeting-session
// starts carry stronger, live process-resolution evidence and bypass
// the cached inventory (the tap is virtual; a resolved mic may have
@@ -203,15 +246,25 @@ impl DeviceManager {
.unwrap_or(false)
}
- pub async fn stop_all_devices(&self) -> Result<()> {
- for pair in self.states.iter() {
- let device = pair.key();
- let _ = self.stop_device(device).await;
+ pub async fn stop_all_devices(self: &Arc<Self>) -> Result<()> {
+ // Include admitted starts that have not published their stream yet.
+ let mut devices: Vec<_> = self.operations.iter().map(|p| p.key().clone()).collect();
+ devices.extend(self.streams.iter().map(|p| p.key().clone()));
+ let mut seen = std::collections::HashSet::new();
+ let mut failure = None;
+ for device in devices.into_iter().filter(|d| seen.insert(d.clone())) {
+ let manager = self.clone();
+ let target = device.clone();
+ if let Err(e) = self
+ .run_device_operation(&device, async move { manager.stop_device(&target).await })
+ .await
+ {
+ failure = Some(e);
+ }
+ }
+ if let Some(e) = failure {
+ return Err(e);
}
-
- self.states.clear();
- self.streams.clear();
-
Ok(())
}
@@ -240,8 +293,10 @@ impl DeviceManager {
is_running.store(false, Ordering::Relaxed)
}
- if let Some(p) = self.streams.get(device) {
- let _ = p.value().stop().await;
+ // Never hold a DashMap guard across native teardown. Retain the stream
+ // on timeout so a later start cannot orphan a still-running worker.
+ if let Some(stream) = self.stream(device) {
+ stream.stop().await?;
}
self.streams.remove(device);
@@ -260,6 +315,107 @@ mod tests {
use crate::core::device::DeviceType;
use crate::core::stream::AudioStream;
+ #[tokio::test]
+ async fn published_stream_is_not_reopened_before_recording_handle_registration() {
+ let dm = DeviceManager::new(false, false, false).await.unwrap();
+ let device = mic();
+ let (stream, _tx) = AudioStream::from_sender_for_test(Arc::new(device.clone()), 48_000, 1);
+ let stream = Arc::new(stream);
+ dm.streams.insert(device.clone(), stream.clone());
+ dm.states
+ .insert(device.clone(), Arc::new(AtomicBool::new(false)));
+ let error = dm.start_process_resolved_device(&device).await.unwrap_err();
+ assert!(error.to_string().contains("already running"));
+ assert!(Arc::ptr_eq(&stream, &dm.stream(&device).unwrap()));
+ dm.stop_device(&device).await.unwrap();
+ }
+
+ #[tokio::test]
+ async fn cancelled_request_keeps_device_owned_until_transition_finishes() {
+ let dm = Arc::new(DeviceManager::new(false, false, false).await.unwrap());
+ let device = mic();
+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();
+ let first_manager = dm.clone();
+ let first_device = device.clone();
+ let first = tokio::spawn(async move {
+ first_manager
+ .run_device_operation(&first_device, async move {
+ entered_tx.send(()).unwrap();
+ release_rx.await.unwrap();
+ Ok(())
+ })
+ .await
+ });
+ entered_rx.await.unwrap();
+ first.abort();
+ let _ = first.await;
+
+ let (second_tx, mut second_rx) = tokio::sync::oneshot::channel();
+ let second_manager = dm.clone();
+ let second = tokio::spawn(async move {
+ second_manager
+ .run_device_operation(&device, async move {
+ second_tx.send(()).unwrap();
+ Ok(())
+ })
+ .await
+ });
+ assert!(
+ tokio::time::timeout(Duration::from_millis(50), &mut second_rx)
+ .await
+ .is_err()
+ );
+ // The mic's stalled operation must not block independent system audio.
+ let output = AudioDevice::new("System Audio".into(), DeviceType::Output);
+ tokio::time::timeout(
+ Duration::from_secs(1),
+ dm.run_device_operation(&output, async { Ok(()) }),
+ )
+ .await
+ .unwrap()
+ .unwrap();
+ release_tx.send(()).unwrap();
+ tokio::time::timeout(Duration::from_secs(1), second_rx)
+ .await
+ .unwrap()
+ .unwrap();
+ second.await.unwrap().unwrap();
+ }
+
+ #[tokio::test]
+ async fn global_stop_waits_for_startup_before_removing_the_stream() {
+ let dm = Arc::new(DeviceManager::new(false, false, false).await.unwrap());
+ let device = mic();
+ let (stream, _tx) = AudioStream::from_sender_for_test(Arc::new(device.clone()), 48_000, 1);
+ let stream = Arc::new(stream);
+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();
+ let owner = dm.clone();
+ let starting = dm.clone();
+ let target = device.clone();
+ let starting_stream = stream.clone();
+ let start = tokio::spawn(async move {
+ owner.run_device_operation(&target.clone(), async move {
+ entered_tx.send(()).unwrap();
+ release_rx.await.unwrap();
+ starting.streams.insert(target.clone(), starting_stream);
+ starting.states.insert(target, Arc::new(AtomicBool::new(true)));
+ Ok(())
+ }).await
+ });
+ entered_rx.await.unwrap();
+ let stopping = dm.clone();
+ let mut stop = tokio::spawn(async move { stopping.stop_all_devices().await });
+ assert!(tokio::time::timeout(Duration::from_millis(50), &mut stop).await.is_err());
+ release_tx.send(()).unwrap();
+ start.await.unwrap().unwrap();
+ tokio::time::timeout(Duration::from_secs(1), stop).await.unwrap().unwrap().unwrap();
+ assert!(stream.is_disconnected());
+ assert!(dm.stream(&device).is_none());
+ assert!(!dm.is_running(&device));
+ }
+
#[test]
fn process_resolved_meeting_devices_bypass_inventory_validation() {
assert!(DeviceResolution::Inventory.requires_inventory());