Fix ALSA device not closing (#233) (#241)

This PR fixes the issue of ALSA staying open after stream end (#233), by
calling the existing `AudioPlayer::_close_stream` from
`AudioStreamHandler::_on_stream_end`.

Tested on Linux, with this change the ALSA stream immediatecly closes on
pause, and resumes on play. Haven't tested any othere audio backends.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: chatziko

sendspin/audio.py

@@ -330,6 +330,19 @@ def stop(self) -> None:
         self._close_stream()
         self._stream_executor.shutdown(wait=True)
 
+    def close_stream(self) -> None:
+        """Drop queued audio and fully close the stream to release the device.
+
+        Unlike clear(), which only stops the stream (leaving the device FD open),
+        this fully closes the PortAudio stream. Call when the server signals
+        end-of-stream; the stream will be recreated by set_format() when the
+        next track begins.
+        """
+        if self._closed:
+            return
+        self.clear()
+        self._close_stream()
+
     def clear(self) -> None:
         """Drop all queued audio chunks."""
         if self._closed:

sendspin/audio_connector.py

@@ -61,8 +61,18 @@ class _StopWorkItem:
     """Stop signal for the synchronous audio worker."""
 
 
+@dataclass(slots=True)
+class _CloseStreamWorkItem:
+    """Close the audio stream and release the audio device on stream end."""
+
+
 type _AudioWorkItem = (
-    _ChunkWorkItem | _ClearWorkItem | _SetVolumeWorkItem | _DelayChangeWorkItem | _StopWorkItem
+    _ChunkWorkItem
+    | _ClearWorkItem
+    | _SetVolumeWorkItem
+    | _DelayChangeWorkItem
+    | _StopWorkItem
+    | _CloseStreamWorkItem
 )
 
 
@@ -119,6 +129,10 @@ def clear(self) -> None:
         """Clear queued audio on worker."""
         self._enqueue(_ClearWorkItem())
 
+    def close_stream(self) -> None:
+        """Clear queued audio and close the stream to release the audio device."""
+        self._enqueue(_CloseStreamWorkItem())
+
     def notify_delay_change(self, delta_us: int) -> None:
         """Notify the worker that static delay changed."""
         self._enqueue(_DelayChangeWorkItem(delta_us=delta_us))
@@ -198,6 +212,11 @@ def _run(
                 player.clear()
                 continue
 
+            if item_type is _CloseStreamWorkItem:
+                player.close_stream()
+                current_format = None  # force set_format() when next track begins
+                continue
+
             if item_type is _DelayChangeWorkItem:
                 player.apply_delay_change(cast(_DelayChangeWorkItem, item).delta_us)
                 continue
@@ -218,6 +237,7 @@ def _run(
                 buffered_chunks: list[_ChunkWorkItem] = [chunk_item]
                 drained = player.is_drained()
                 deadline = time.monotonic() + 60.0
+                close_requested = False
 
                 while not drained and time.monotonic() < deadline:
                     try:
@@ -230,8 +250,12 @@ def _run(
                     if drain_type is _StopWorkItem:
                         player.stop()
                         return
-                    if drain_type is _ClearWorkItem:
-                        player.clear()
+                    if drain_type is _ClearWorkItem or drain_type is _CloseStreamWorkItem:
+                        if drain_type is _CloseStreamWorkItem:
+                            player.close_stream()
+                            close_requested = True
+                        else:
+                            player.clear()
                         buffered_chunks.clear()
                         drained = True
                         break
@@ -252,6 +276,10 @@ def _run(
                     logger.warning("Drain timeout during format switch; forcing clear")
                     player.clear()
 
+                if close_requested:
+                    current_format = None
+                    continue
+
                 current_format = fmt
                 player.set_format(fmt, device=self._audio_device)
 
@@ -515,11 +543,13 @@ def _on_stream_start(self, message: StreamStartMessage) -> None:
                 self._on_event("start")
 
     def _on_stream_end(self, roles: list[str] | None) -> None:
-        """Handle stream end by clearing audio queue."""
+        """Handle stream end by closing the audio stream to release the audio device."""
         if roles is not None and Roles.PLAYER.value not in roles:
             return
 
-        self._clear_audio_worker()
+        worker = self._audio_worker
+        if worker is not None and worker.is_running():
+            worker.close_stream()
 
         if self._stream_active:
             self._stream_active = False

tests/test_audio_connector.py

@@ -24,6 +24,8 @@ def __init__(
         self.volume = volume
         self.muted = muted
         self.running = False
+        self.cleared = False
+        self.stream_closed = False
         self.submitted: list[tuple[int, bytes | bytearray, object]] = []
         _FakeWorker.instances.append(self)
 
@@ -41,7 +43,10 @@ def submit_chunk(
         self.submitted.append((server_timestamp_us, audio_data, fmt))
 
     def clear(self) -> None:
-        return
+        self.cleared = True
+
+    def close_stream(self) -> None:
+        self.stream_closed = True
 
     def set_volume(self, volume: int, *, muted: bool) -> None:
         self.volume = volume
@@ -247,3 +252,25 @@ async def exercise() -> None:
         assert changes == [(41, False)]
 
     asyncio.run(exercise())
+
+
+def test_stream_end_closes_stream_not_just_clears(monkeypatch) -> None:
+    """stream_end must fully close the stream (release the device), not just clear."""
+    monkeypatch.setattr(audio_connector, "_AudioSyncWorker", _FakeWorker)
+    _FakeWorker.instances.clear()
+
+    handler = AudioStreamHandler(
+        audio_device=SimpleNamespace(index=0, name="Fake Device"),
+        volume=10,
+        muted=False,
+    )
+    client = _FakeClient()
+    handler.attach_client(client)
+
+    worker = _FakeWorker.instances[0]
+    assert not worker.stream_closed
+
+    handler._on_stream_end(None)
+
+    assert worker.stream_closed, "_on_stream_end must call close_stream(), not just clear()"
+    assert not worker.cleared, "_on_stream_end must not call clear() separately"