music-assistant-server

1"""
2Sonos Player provider for Music Assistant for speakers running the S2 firmware.
3
4Based on the aiosonos library, which leverages the new websockets API of the Sonos S2 firmware.
5https://github.com/music-assistant/aiosonos
6"""
7
8from __future__ import annotations
9
10import logging
11from typing import TYPE_CHECKING, Any, cast
12
13from aiohttp import web
14from aiohttp.client_exceptions import ClientError
15from aiosonos.api.models import SonosCapability
16from aiosonos.utils import get_discovery_info
17from music_assistant_models.enums import IdentifierType
18from zeroconf import ServiceStateChange
19
20from music_assistant.constants import (
21    CONF_ENTRY_MANUAL_DISCOVERY_IPS,
22    CONF_LOG_LEVEL,
23    MASS_LOGO_ONLINE,
24    VERBOSE_LOG_LEVEL,
25)
26from music_assistant.helpers.audio import get_mime_type
27from music_assistant.helpers.json import SerializableType
28from music_assistant.models.player_provider import PlayerProvider
29
30from .helpers import get_primary_ip_address
31from .player import SonosPlayer
32
33if TYPE_CHECKING:
34    from music_assistant_models.config_entries import ConfigEntry, ProviderConfig
35    from music_assistant_models.player import PlayerMedia
36    from zeroconf.asyncio import AsyncServiceInfo
37
38
39class SonosPlayerProvider(PlayerProvider):
40    """Sonos Player provider."""
41
42    _ignored_disabled_players: set[str]
43
44    async def get_config_entries(self) -> tuple[ConfigEntry, ...]:
45        """Return Config entries to setup this provider."""
46        return (CONF_ENTRY_MANUAL_DISCOVERY_IPS,)
47
48    async def handle_async_init(self) -> None:
49        """Handle async initialization of the provider."""
50        self._ignored_disabled_players = set()
51        self._set_aiosonos_log_level()
52        self.mass.streams.register_dynamic_route(
53            "/sonos_queue/*", self._handle_sonos_cloud_queue_request
54        )
55
56    async def loaded_in_mass(self) -> None:
57        """Call after the provider has been loaded."""
58        await super().loaded_in_mass()
59        # Handle config option for manual IP's
60        manual_ip_config = cast(
61            "list[str]", self.config.get_value(CONF_ENTRY_MANUAL_DISCOVERY_IPS.key)
62        )
63        for ip_address in manual_ip_config:
64            try:
65                # get discovery info from SONOS speaker so we can provide an ID & other info
66                discovery_info = await get_discovery_info(self.mass.http_session_no_ssl, ip_address)
67            except ClientError as err:
68                self.logger.debug(
69                    "Ignoring %s (manual IP) as it is not reachable: %s", ip_address, str(err)
70                )
71                continue
72            player_id = discovery_info["device"]["id"]
73            sonos_player = SonosPlayer(self, player_id, discovery_info=discovery_info)
74            sonos_player.device_info.add_identifier(IdentifierType.IP_ADDRESS, ip_address)
75            await sonos_player.setup()
76
77    async def unload(self, is_removed: bool = False) -> None:
78        """Handle close/cleanup of the provider."""
79        self.mass.streams.unregister_dynamic_route("/sonos_queue/*")
80
81    async def update_config(self, config: ProviderConfig, changed_keys: set[str]) -> None:
82        """Handle logic when the config is updated."""
83        await super().update_config(config, changed_keys)
84        # a log level(-only) change does not reload the provider,
85        # so realign aiosonos's logger here
86        if f"values/{CONF_LOG_LEVEL}" in changed_keys:
87            self._set_aiosonos_log_level()
88
89    async def get_diagnostics(self) -> dict[str, SerializableType]:
90        """Return diagnostics info for this provider to include in diagnostics reports."""
91        sonos_players = [player for player in self.players if isinstance(player, SonosPlayer)]
92        # active_output_protocol holds "native" or the player id of the protocol player in use
93        active_protocols = [
94            player.active_output_protocol
95            for player in sonos_players
96            if player.active_output_protocol
97        ]
98        return {
99            "speakers_total": len(sonos_players),
100            "speakers_connected": sum(player.connected for player in sonos_players),
101            "coordinators": sum(
102                player.client.player.is_coordinator for player in sonos_players if player.connected
103            ),
104            "native_playback": sum(protocol == "native" for protocol in active_protocols),
105            "protocol_playback": sum(protocol != "native" for protocol in active_protocols),
106        }
107
108    async def on_mdns_service_state_change(
109        self, name: str, state_change: ServiceStateChange, info: AsyncServiceInfo | None
110    ) -> None:
111        """Handle MDNS service state callback."""
112        if state_change == ServiceStateChange.Removed:
113            # we don't listen for removed players here.
114            # instead we just wait for the player connection to fail
115            return
116        assert info is not None  # for type checking
117        if "uuid" not in info.decoded_properties:
118            # not a S2 player
119            return
120        name = name.split("@", 1)[1] if "@" in name else name
121        player_id = info.decoded_properties["uuid"]
122        assert isinstance(player_id, str)  # for type checking
123        # handle update for existing device
124        if sonos_player := self.mass.players.get_player(player_id):
125            assert isinstance(sonos_player, SonosPlayer), (
126                "Player ID already exists but is not a SonosPlayer"
127            )
128            # if mass_player := sonos_player.mass_player:
129            cur_address = get_primary_ip_address(info)
130            if cur_address and cur_address != sonos_player.device_info.ip_address:
131                sonos_player.logger.debug(
132                    "Address updated from %s to %s",
133                    sonos_player.device_info.ip_address,
134                    cur_address,
135                )
136                sonos_player.device_info.add_identifier(IdentifierType.IP_ADDRESS, cur_address)
137            if not sonos_player.connected and cur_address:
138                self.logger.debug("Player back online: %s", sonos_player.display_name)
139                sonos_player.client.player_ip = cur_address
140                # schedule reconnect
141                sonos_player.reconnect()
142            self.mass.players.trigger_player_update(player_id)
143            return
144        if self._ignore_disabled_discovery(player_id, name):
145            return
146        # handle new player setup in a delayed task because mdns announcements
147        # can arrive in (duplicated) bursts
148        task_id = f"setup_sonos_{player_id}"
149        self.mass.call_later(5, self._setup_player, player_id, name, info, task_id=task_id)
150
151    def _set_aiosonos_log_level(self) -> None:
152        """Align aiosonos's log level with the provider's log level."""
153        # aiosonos is very chatty at debug level, so only pass through its
154        # debug logging when verbose logging is enabled
155        if self.logger.isEnabledFor(VERBOSE_LOG_LEVEL):
156            logging.getLogger("aiosonos").setLevel(logging.DEBUG)
157        else:
158            logging.getLogger("aiosonos").setLevel(self.logger.level + 10)
159
160    async def _setup_player(self, player_id: str, name: str, info: AsyncServiceInfo) -> None:
161        """Handle setup of a new player that is discovered using mdns."""
162        if self.mass.players.get_player(player_id):
163            msg = f"Player {player_id} already exists"
164            raise ValueError(msg)
165        if self._ignore_disabled_discovery(player_id, name):
166            return
167        address = get_primary_ip_address(info)
168        if address is None:
169            return
170        try:
171            discovery_info = await get_discovery_info(self.mass.http_session_no_ssl, address)
172        except ClientError as err:
173            self.logger.debug("Ignoring %s in discovery as it is not reachable: %s", name, str(err))
174            return
175        display_name = discovery_info["device"].get("name") or name
176        if SonosCapability.PLAYBACK not in discovery_info["device"]["capabilities"]:
177            # this will happen for satellite speakers in a surround/stereo setup
178            self.logger.debug(
179                "Ignoring %s in discovery as it is a passive satellite.", display_name
180            )
181            return
182        self.logger.debug("Discovered Sonos device %s on %s", name, address)
183        sonos_player = SonosPlayer(self, player_id, discovery_info=discovery_info)
184        sonos_player.device_info.add_identifier(IdentifierType.IP_ADDRESS, address)
185        await sonos_player.setup()
186
187    def _ignore_disabled_discovery(self, player_id: str, name: str) -> bool:
188        """
189        Return whether discovery should ignore a disabled player.
190
191        :param player_id: The discovered Sonos player ID.
192        :param name: The discovered Sonos service name.
193        """
194        if self.mass.config.get_raw_player_config_value(player_id, "enabled", True):
195            self._ignored_disabled_players.discard(player_id)
196            return False
197        if player_id not in self._ignored_disabled_players:
198            self.logger.debug("Ignoring %s in discovery as it is disabled.", name)
199            self._ignored_disabled_players.add(player_id)
200        return True
201
202    async def _handle_sonos_cloud_queue_request(self, request: web.Request) -> web.Response:
203        """
204        Handle the Sonos CloudQueue request.
205
206        https://docs.sonos.com/reference/itemwindow
207        """
208        self.logger.log(
209            VERBOSE_LOG_LEVEL,
210            "Cloud Queue request\n - path: %s\n - query: %s\n",
211            request.path,
212            request.query,
213        )
214        path_parts = request.path.strip("/").split("/")
215        if len(path_parts) != 4 or path_parts[0] != "sonos_queue":
216            return web.Response(status=404)
217        player_id = path_parts[1]
218        if not (sonos_player := self.mass.players.get_player(player_id)):
219            return web.Response(status=501)
220        if TYPE_CHECKING:
221            assert isinstance(sonos_player, SonosPlayer)
222        endpoint = path_parts[3]
223        if endpoint == "itemWindow":
224            return await self._handle_sonos_queue_itemwindow(sonos_player, request)
225        if endpoint == "version":
226            return await self._handle_sonos_queue_version(sonos_player, request)
227        if endpoint == "context":
228            return await self._handle_sonos_queue_context(sonos_player, request)
229        if endpoint == "timePlayed":
230            return await self._handle_sonos_queue_time_played(sonos_player, request)
231        return web.Response(status=404)
232
233    async def _handle_sonos_queue_itemwindow(
234        self, player: SonosPlayer, request: web.Request
235    ) -> web.Response:
236        """
237        Handle the Sonos CloudQueue ItemWindow endpoint.
238
239        https://docs.sonos.com/reference/itemwindow
240        """
241        context_version = request.query.get("contextVersion", "1")
242        # because Sonos does not show our queue in the app anyways,
243        # we just return the previous, current and next item in the queue.
244        # the beginning/end flags must be honest though: signalling end-of-queue
245        # tells Sonos to drop any older items it may still have cached past our
246        # window, which is what prevents stale tracks from resurrecting after a
247        # queue rewrite (e.g. replace_next).
248        items = list(player.sonos_queue.items)
249        result = {
250            "includesBeginningOfQueue": player.sonos_queue.includes_beginning,
251            "includesEndOfQueue": player.sonos_queue.includes_end,
252            "contextVersion": context_version,
253            # report the version of the items we actually serve (the current window) instead of
254            # echoing the player's requested version, otherwise a refreshed window keeps a stale
255            # version label and Sonos never realises it changed.
256            "queueVersion": str(player.sonos_queue.last_updated),
257            "items": [self._parse_sonos_queue_item(x) for x in items],
258        }
259        return web.json_response(result)
260
261    async def _handle_sonos_queue_version(
262        self, player: SonosPlayer, request: web.Request
263    ) -> web.Response:
264        """
265        Handle the Sonos CloudQueue Version endpoint.
266
267        https://docs.sonos.com/reference/version
268        """
269        context_version = request.query.get("contextVersion") or "1"
270        # keep sub-second resolution: the window can be rebuilt several times within the same
271        # second and Sonos treats an unchanged queueVersion as "nothing changed" (stale window).
272        result = {
273            "contextVersion": context_version,
274            "queueVersion": str(player.sonos_queue.last_updated),
275        }
276        return web.json_response(result)
277
278    async def _handle_sonos_queue_context(
279        self, player: SonosPlayer, request: web.Request
280    ) -> web.Response:
281        """
282        Handle the Sonos CloudQueue Context endpoint.
283
284        https://docs.sonos.com/reference/context
285        """
286        result = {
287            "contextVersion": "1",
288            "queueVersion": str(player.sonos_queue.last_updated),
289            "container": {
290                "type": "trackList",
291                "name": "Music Assistant",
292                "imageUrl": MASS_LOGO_ONLINE,
293                "service": {"name": "Music Assistant", "id": "mass"},
294                "id": {
295                    "serviceId": "mass",
296                    "objectId": f"mass:{player.sonos_queue.items[-1].source_id}"
297                    if player.sonos_queue.items
298                    else "mass:unknown",
299                    "accountId": "",
300                },
301            },
302            "reports": {
303                "sendUpdateAfterMillis": 1000,
304                "periodicIntervalMillis": 30000,
305                "sendPlaybackActions": True,
306            },
307            "playbackPolicies": {
308                "canSkip": True,
309                "limitedSkips": True,
310                "canSkipToItem": True,  # unsure
311                "canSkipBack": True,
312                # seek needs to be disabled because we dont properly support range requests
313                "canSeek": False,
314                "canRepeat": False,  # handled by MA queue controller
315                "canRepeatOne": False,  # synced from MA queue controller
316                "canCrossfade": False,  # handled by MA queue controller
317                "canShuffle": False,  # handled by MA queue controller
318            },
319        }
320        return web.json_response(result)
321
322    async def _handle_sonos_queue_time_played(
323        self, player: SonosPlayer, request: web.Request
324    ) -> web.Response:
325        """
326        Handle the Sonos CloudQueue TimePlayed endpoint.
327
328        https://docs.sonos.com/reference/timeplayed
329        """
330        json_body = await request.json()
331        for item in json_body["items"]:
332            if item["type"] != "update":
333                continue
334            if "positionMillis" not in item:
335                continue
336            if player.current_media and player.current_media.queue_item_id == item["id"]:
337                player.update_elapsed_time(item["positionMillis"] / 1000)
338            break
339        return web.Response(status=204)
340
341    def _parse_sonos_queue_item(self, media: PlayerMedia) -> dict[str, Any]:
342        """Parse MusicAssistant PlayerMedia to a Sonos Media (queue) object."""
343        # the speaker tracks its position within the audio we serve, which is
344        # shorter than the media item when playback starts at a seek position
345        duration = media.stream_duration or media.duration
346        return {
347            "id": media.queue_item_id or media.uri,
348            "track": {
349                "type": "track",
350                "mediaUrl": media.uri,
351                "contentType": get_mime_type(media.uri.split(".")[-1]),
352                "service": {"name": "Music Assistant", "id": "mass"},
353                "name": media.title,
354                "imageUrl": media.image_url,
355                "durationMillis": int(duration * 1000) if duration else 0,
356                "artist": {
357                    "name": media.artist,
358                }
359                if media.artist
360                else None,
361                "album": {
362                    "name": media.album,
363                }
364                if media.album
365                else None,
366            },
367        }
368