fix issues with chromecast

Author: marcelveldt

music_assistant/config.py

@@ -252,7 +252,7 @@ def __setitem__(self, key, value):
                         self.mass.get_provider(self._parent_item_key).async_on_reload()
                     )
                 if self._base_type == ConfigBaseType.PLAYER:
-
+                    # force update of player if it's config changed
                     player = self.mass.player_manager.get_player(self._parent_item_key)
                     if player:
                         self.mass.add_job(

music_assistant/constants.py

@@ -1,6 +1,6 @@
 """All constants for Music Assistant."""
 
-__version__ = "0.0.36"
+__version__ = "0.0.37"
 REQUIRED_PYTHON_VER = "3.7"
 
 CONF_USERNAME = "username"

music_assistant/models/player_queue.py

@@ -54,10 +54,10 @@ def __init__(self, media_item=None):
 class PlayerQueue:
     """Class that holds the queue items for a player."""
 
-    def __init__(self, mass, player):
+    def __init__(self, mass, player_id: str):
         """Initialize class."""
         self.mass = mass
-        self._player = player
+        self._player_id = player_id
         self._items = []
         self._shuffle_enabled = False
         self._repeat_enabled = False
@@ -78,12 +78,12 @@ async def async_close(self):
     @property
     def player(self):
         """Return handle to player."""
-        return self._player
+        return self.mass.player_manager.get_player(self._player_id)
 
     @property
     def player_id(self):
         """Return handle to player."""
-        return self._player.player_id
+        return self._player_id
 
     @property
     def shuffle_enabled(self):
@@ -213,9 +213,21 @@ def use_queue_stream(self):
         For example if crossfading is requested but a player doesn't natively support it
         we will send a constant stream of audio to the player with all tracks.
         """
-        supports_crossfade = PlayerFeature.CROSSFADE in self.player.features
-        supports_queue = PlayerFeature.QUEUE in self.player.features
-        return not supports_crossfade if self.crossfade_enabled else not supports_queue
+        return (
+            not self.supports_crossfade
+            if self.crossfade_enabled
+            else not self.supports_queue
+        )
+
+    @property
+    def supports_queue(self):
+        """Return if this player supports native queue."""
+        return PlayerFeature.QUEUE in self.player.features
+
+    @property
+    def supports_crossfade(self):
+        """Return if this player supports native crossfade."""
+        return PlayerFeature.CROSSFADE in self.player.features
 
     @callback
     def get_item(self, index):
@@ -240,7 +252,6 @@ async def async_next(self):
             return
         if self.use_queue_stream:
             return await self.async_play_index(self.cur_index + 1)
-        await self.mass.player_manager.async_cmd_power_on(self.player_id)
         return await self.mass.player_manager.get_player_provider(
             self.player_id
         ).async_cmd_next(self.player_id)
@@ -249,18 +260,15 @@ async def async_previous(self):
         """Play the previous track in the queue."""
         if self.cur_index is None:
             return
-        await self.mass.player_manager.async_cmd_power_on(self.player_id)
         if self.use_queue_stream:
             return await self.async_play_index(self.cur_index - 1)
         return await self.mass.player_manager.async_cmd_previous(self.player_id)
 
     async def async_resume(self):
         """Resume previous queue."""
         if self.items:
-            await self.mass.player_manager.async_cmd_power_on(self.player_id)
             prev_index = self.cur_index
-            supports_queue = PlayerFeature.QUEUE in self.player.features
-            if self.use_queue_stream or not supports_queue:
+            if self.use_queue_stream or not self.supports_queue:
                 await self.async_play_index(prev_index)
             else:
                 # at this point we don't know if the queue is synced with the player
@@ -272,14 +280,12 @@ async def async_resume(self):
                 await self.async_play_index(prev_index)
         else:
             LOGGER.warning(
-                "resume queue requested for %s but queue is empty", self.player.name
+                "resume queue requested for %s but queue is empty", self.player_id
             )
 
     async def async_play_index(self, index):
         """Play item at index X in queue."""
-        await self.mass.player_manager.async_cmd_power_on(self.player_id)
         player_prov = self.mass.player_manager.get_player_provider(self.player_id)
-        supports_queue = PlayerFeature.QUEUE in self.player.features
         if not isinstance(index, int):
             index = self.__index_by_id(index)
         if not len(self.items) > index:
@@ -297,7 +303,7 @@ async def async_play_index(self, index):
             return await player_prov.async_cmd_play_uri(
                 self.player_id, queue_stream_uri
             )
-        if supports_queue:
+        if self.supports_queue:
             try:
                 return await player_prov.async_cmd_queue_play_index(
                     self.player_id, index
@@ -342,14 +348,12 @@ async def async_move_item(self, queue_item_id, pos_shift=1):
 
     async def async_load(self, queue_items: List[QueueItem]):
         """Load (overwrite) queue with new items."""
-        await self.mass.player_manager.async_cmd_power_on(self.player_id)
-        supports_queue = PlayerFeature.QUEUE in self.player.features
         for index, item in enumerate(queue_items):
             item.sort_index = index
         if self._shuffle_enabled:
             queue_items = self.__shuffle_items(queue_items)
         self._items = queue_items
-        if self.use_queue_stream or not supports_queue:
+        if self.use_queue_stream or not self.supports_queue:
             await self.async_play_index(0)
         else:
             player_prov = self.mass.player_manager.get_player_provider(self.player_id)
@@ -366,7 +370,6 @@ async def async_insert(self, queue_items: List[QueueItem], offset=0):
             :param queue_items: a list of QueueItem
             :param offset: offset from current queue position
         """
-        supports_queue = PlayerFeature.QUEUE in self.player.features
 
         if (
             not self.items
@@ -393,7 +396,7 @@ async def async_insert(self, queue_items: List[QueueItem], offset=0):
                 + queue_items
                 + self._items[insert_at_index:]
             )
-        if self.use_queue_stream or not supports_queue:
+        if self.use_queue_stream:
             if offset == 0:
                 await self.async_play_index(insert_at_index)
         else:
@@ -417,7 +420,6 @@ async def async_insert(self, queue_items: List[QueueItem], offset=0):
 
     async def async_append(self, queue_items: List[QueueItem]):
         """Append new items at the end of the queue."""
-        supports_queue = PlayerFeature.QUEUE in self.player.features
         for index, item in enumerate(queue_items):
             item.sort_index = len(self.items) + index
         if self.shuffle_enabled:
@@ -427,7 +429,7 @@ async def async_append(self, queue_items: List[QueueItem]):
             items = played_items + [self.cur_item] + next_items
             return await self.async_update(items)
         self._items = self._items + queue_items
-        if supports_queue and not self.use_queue_stream:
+        if self.supports_queue and not self.use_queue_stream:
             # send queue to player's own implementation
             player_prov = self.mass.player_manager.get_player_provider(self.player_id)
             try:
@@ -446,9 +448,8 @@ async def async_append(self, queue_items: List[QueueItem]):
 
     async def async_update(self, queue_items: List[QueueItem]):
         """Update the existing queue items, mostly caused by reordering."""
-        supports_queue = PlayerFeature.QUEUE in self.player.features
         self._items = queue_items
-        if supports_queue and not self.use_queue_stream:
+        if self.supports_queue and not self.use_queue_stream:
             # send queue to player's own implementation
             player_prov = self.mass.player_manager.get_player_provider(self.player_id)
             try:
@@ -467,10 +468,9 @@ async def async_update(self, queue_items: List[QueueItem]):
 
     async def async_clear(self):
         """Clear all items in the queue."""
-        supports_queue = PlayerFeature.QUEUE in self.player.features
         await self.mass.player_manager.async_cmd_stop(self.player_id)
         self._items = []
-        if supports_queue:
+        if self.supports_queue:
             # send queue cmd to player's own implementation
             player_prov = self.mass.player_manager.get_player_provider(self.player_id)
             try:

music_assistant/player_manager.py

@@ -98,9 +98,8 @@ def providers(self) -> List[PlayerProvider]:
     def get_player(self, player_id: str) -> Player:
         """Return player by player_id or None if player does not exist."""
         player = self._players.get(player_id)
-        if not player or not player.available:
+        if not player:
             LOGGER.warning("Player %s is not available!", player_id)
-            return None
         return player
 
     @callback
@@ -147,7 +146,9 @@ async def async_add_player(self, player: Player) -> None:
         if is_new_player:
             # create player queue
             if player.player_id not in self._player_queues:
-                self._player_queues[player.player_id] = PlayerQueue(self.mass, player)
+                self._player_queues[player.player_id] = PlayerQueue(
+                    self.mass, player.player_id
+                )
             # TODO: turn on player if it was previously turned on ?
             LOGGER.info(
                 "New player added: %s/%s",

music_assistant/providers/chromecast/__init__.py

@@ -59,9 +59,13 @@ async def async_on_start(self) -> bool:
             self.__chromecast_remove_callback,
             self.__chromecast_add_update_callback,
         )
-        self._browser = pychromecast.discovery.start_discovery(
-            self._listener, self.mass.zeroconf
-        )
+
+        def start_discovery():
+            self._browser = pychromecast.discovery.start_discovery(
+                self._listener, self.mass.zeroconf
+            )
+
+        self.mass.add_job(start_discovery)
         return True
 
     async def async_on_stop(self):
@@ -76,7 +80,7 @@ async def async_on_stop(self):
 
     async def async_cmd_play_uri(self, player_id: str, uri: str):
         """
-        Play the specified uri/url on the goven player.
+        Play the specified uri/url on the given player.
 
             :param player_id: player_id of the player to handle the command.
         """
@@ -191,15 +195,13 @@ def __chromecast_add_update_callback(self, cast_uuid, cast_service_name):
             port=service[5],
         )
         player_id = cast_info.uuid
-        LOGGER.debug(
-            "Chromecast discovered: %s (%s)", cast_info.friendly_name, player_id
-        )
         if player_id in self._players:
             # player already added, the player will take care of reconnects itself.
+            return
+        else:
             LOGGER.debug(
-                "Player is already added:  %s (%s)", cast_info.friendly_name, player_id
+                "Chromecast discovered: %s (%s)", cast_info.friendly_name, player_id
             )
-        else:
             player = ChromecastPlayer(self.mass, cast_info)
             self._players[player_id] = player
             self.mass.add_job(self.mass.player_manager.async_add_player(player))

music_assistant/providers/chromecast/player.py

@@ -210,7 +210,6 @@ def _invalidate(self):
 
     def new_cast_status(self, cast_status):
         """Handle updates of the cast status."""
-        LOGGER.debug("received cast status for %s", self.name)
         self.cast_status = cast_status
         self._is_speaker_group = (
             self._cast_info.is_audio_group
@@ -224,15 +223,13 @@ def new_cast_status(self, cast_status):
 
     def new_media_status(self, media_status):
         """Handle updates of the media status."""
-        LOGGER.debug("received media_status for %s", self.name)
         self.media_status = media_status
         self.mass.add_job(self.mass.player_manager.async_update_player(self))
         if media_status.player_is_playing:
             self._powered = True
 
     def new_connection_status(self, connection_status):
         """Handle updates of connection status."""
-        LOGGER.debug("received connection_status for %s", self._cast_info.friendly_name)
         if connection_status.status == CONNECTION_STATUS_DISCONNECTED:
             self._available = False
             self._invalidate()
@@ -305,7 +302,9 @@ def power_off(self):
             LOGGER.warning("Ignore player command: Socket client is not connected.")
             return
         if self.media_status and (
-            self.media_status.player_is_playing or self.media_status.player_is_paused
+            self.media_status.player_is_playing
+            or self.media_status.player_is_paused
+            or self.media_status.player_is_idle
         ):
             self._chromecast.media_controller.stop()
         self._powered = False