Fix some small issues with AirPlay and sendspin bridging (music-assistant#3313)

Author: marcelveldt

music_assistant/providers/airplay/constants.py

@@ -41,8 +41,8 @@ class StreamingProtocol(IntEnum):
 # Maximum output buffer duration permitted.
 AIRPLAY_OUTPUT_BUFFER_MAX_DURATION_MS: Final[int] = 5000
 AIRPLAY2_MIN_LOG_LEVEL: Final[int] = 3  # Min loglevel to ensure stderr output contains what we need
-AIRPLAY2_CONNECT_TIME_MS: Final[int] = 2000  # Time in ms to allow AirPlay2 device to connect
-RAOP_CONNECT_TIME_MS: Final[int] = 1000  # Time in ms to allow RAOP device to connect
+AIRPLAY2_CONNECT_TIME_MS: Final[int] = 4000  # Time in ms to allow AirPlay2 device to connect
+RAOP_CONNECT_TIME_MS: Final[int] = 1500  # Time in ms to allow RAOP device to connect
 
 # Per-protocol credential storage keys
 CONF_RAOP_CREDENTIALS: Final[str] = "raop_credentials"

music_assistant/providers/airplay/player.py

@@ -20,6 +20,7 @@
 from music_assistant.models.player import DeviceInfo, Player, PlayerMedia
 
 from .constants import (
+    AIRPLAY2_CONNECT_TIME_MS,
     AIRPLAY_DISCOVERY_TYPE,
     AIRPLAY_FLOW_PCM_FORMAT,
     AIRPLAY_OUTPUT_BUFFER_DEFAULT_DURATION_MS,
@@ -43,6 +44,7 @@
     FALLBACK_VOLUME,
     LEGACY_PAIRING_BIT,
     PIN_REQUIRED,
+    RAOP_CONNECT_TIME_MS,
     RAOP_DISCOVERY_TYPE,
     StreamingProtocol,
 )
@@ -156,6 +158,14 @@ def output_buffer_duration_ms(self) -> int:
             self.config.get_value(CONF_AIRPLAY_LATENCY, AIRPLAY_OUTPUT_BUFFER_DEFAULT_DURATION_MS),
         )
 
+    @property
+    def wait_start(self) -> int:
+        """Get the time in ms to allow device to connect before starting stream."""
+        # TODO: make this value configurable ?
+        if self.protocol == StreamingProtocol.AIRPLAY2:
+            return AIRPLAY2_CONNECT_TIME_MS
+        return RAOP_CONNECT_TIME_MS
+
     async def get_config_entries(
         self,
         action: str | None = None,
@@ -293,12 +303,8 @@ def _get_credentials_key(self, protocol: StreamingProtocol) -> str:
 
     def _get_protocol_for_config_value(self, config_option: int) -> StreamingProtocol:
         if config_option == StreamingProtocol.AIRPLAY2:
-            if not self.airplay_discovery_info:
-                raise ValueError("No AirPlay service found for this player")
             return StreamingProtocol.AIRPLAY2
         if config_option == StreamingProtocol.RAOP:
-            if not self.raop_discovery_info:
-                raise ValueError("No RAOP service found for this player")
             return StreamingProtocol.RAOP
         # automatic selection
         if self.airplay_discovery_info and is_airplay2_preferred_model(
@@ -497,6 +503,14 @@ async def stop(self) -> None:
         if self.stream and self.stream.session:
             # forward stop to the entire stream session
             await self.stream.session.stop()
+        elif cast("AirPlayProvider", self.provider).bridge_manager.stop_streaming(self.player_id):
+            # Sendspin bridge active: trigger full bridge cleanup
+            # which stops streaming, kills the CLI, and cancels writer tasks
+            pass
+        elif self.stream and self.stream.running:
+            # Fallback: stop protocol directly
+            await self.stream.stop(force=True)
+            self.stream = None
         self._attr_current_media = None
         self.update_state()
 

music_assistant/providers/airplay/protocols/_protocol.py

@@ -94,16 +94,18 @@ async def stop(self, force: bool = False) -> None:
         """
         # always send stop command first
         await self.send_cli_command("ACTION=STOP")
-        if self._cli_proc:
-            await self._cli_proc.write_eof()
         self._stopped = True
         await self.commands_pipe.remove()
         if force:
+            # Kill immediately - skip write_eof() as it can block indefinitely
+            # when the CLI stops reading from stdin after receiving STOP.
             if self._cli_proc and not self._cli_proc.closed:
                 await self._cli_proc.kill()
-        elif self._cli_proc and not self._cli_proc.closed:
-            await self._cli_proc.close()
-        if not force:
+        else:
+            if self._cli_proc:
+                await self._cli_proc.write_eof()
+            if self._cli_proc and not self._cli_proc.closed:
+                await self._cli_proc.close()
             self.player.set_state_from_stream(state=PlaybackState.IDLE, elapsed_time=0)
 
     async def write_audio(self, data: bytes) -> None:

music_assistant/providers/airplay/provider.py

@@ -43,6 +43,11 @@ class AirPlayProvider(PlayerProvider):
     _dacp_info: AsyncServiceInfo
     _bridge_manager: SendspinBridgeManager
 
+    @property
+    def bridge_manager(self) -> SendspinBridgeManager:
+        """Return the Sendspin bridge manager."""
+        return self._bridge_manager
+
     async def handle_async_init(self) -> None:
         """Handle async initialization of the provider."""
         # Initialize Sendspin bridge manager for protocol linking
@@ -126,6 +131,10 @@ async def _setup_player(
         self, player_id: str, display_name: str, discovery_info: AsyncServiceInfo
     ) -> None:
         """Handle setup of a new player that is discovered using mdns."""
+        # return early if player is disabled in config
+        if not self.mass.config.get_raw_player_config_value(player_id, "enabled", True):
+            self.logger.debug("Ignoring %s in discovery as it is disabled.", display_name)
+            return
         raop_discovery_info: AsyncServiceInfo | None = None
         airplay_discovery_info: AsyncServiceInfo | None = None
         if discovery_info.type == RAOP_DISCOVERY_TYPE:
@@ -139,18 +148,26 @@ async def _setup_player(
                 AIRPLAY_DISCOVERY_TYPE,
                 discovery_info.name.split("@")[-1].replace("_raop", "_airplay"),
             )
-            await airplay_discovery_info.async_request(self.mass.aiozc.zeroconf, 3000)
+            if not await airplay_discovery_info.async_request(self.mass.aiozc.zeroconf, 3000):
+                airplay_discovery_info = None
         else:
             # AirPlay service discovered
             self.logger.debug("Discovered AirPlay service for %s", display_name)
             airplay_discovery_info = discovery_info
+            # also try to get the raop info if available
+            raop_discovery_info = AsyncServiceInfo(
+                RAOP_DISCOVERY_TYPE,
+                discovery_info.name.split("@")[-1].replace("_airplay", "_raop"),
+            )
+            if not await raop_discovery_info.async_request(self.mass.aiozc.zeroconf, 3000):
+                raop_discovery_info = None
 
         if airplay_discovery_info:
             manufacturer, model = get_model_info(airplay_discovery_info)
         elif raop_discovery_info:
             manufacturer, model = get_model_info(raop_discovery_info)
         else:
-            manufacturer, model = "Unknown", "Unknown"
+            return  # should not happen, but guard just in case
 
         address = get_primary_ip_address_from_zeroconf(discovery_info)
         if not address:
@@ -174,12 +191,6 @@ async def _setup_player(
                 if discovery_info.port in receiver_ports:
                     return
 
-        if not self.mass.config.get_raw_player_config_value(player_id, "enabled", True):
-            self.logger.debug("Ignoring %s in discovery as it is disabled.", display_name)
-            return
-        if not discovery_info:
-            return  # should not happen, but guard just in case
-
         # if we reach this point, all preflights are ok and we can create the player
         self.logger.debug("Discovered AirPlay device %s on %s", display_name, address)