""" Support to interface with Sonos players (via SoCo). For more details about this platform, please refer to the documentation at https://home-assistant.io/components/media_player.sonos/ """ import datetime import logging from os import path import socket import urllib import voluptuous as vol from homeassistant.components.media_player import ( ATTR_MEDIA_ENQUEUE, DOMAIN, MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_CLEAR_PLAYLIST, SUPPORT_SELECT_SOURCE, MediaPlayerDevice) from homeassistant.const import ( STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_OFF, ATTR_ENTITY_ID) from homeassistant.config import load_yaml_config_file import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['https://github.com/SoCo/SoCo/archive/' 'cf8c2701165562eccbf1ecc879bf7060ceb0993e.zip#' 'SoCo==0.12'] _LOGGER = logging.getLogger(__name__) # The soco library is excessively chatty when it comes to logging and # causes a LOT of spam in the logs due to making a http connection to each # speaker every 10 seconds. Quiet it down a bit to just actual problems. _SOCO_LOGGER = logging.getLogger('soco') _SOCO_LOGGER.setLevel(logging.ERROR) _REQUESTS_LOGGER = logging.getLogger('requests') _REQUESTS_LOGGER.setLevel(logging.ERROR) SUPPORT_SONOS = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE |\ SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_PLAY_MEDIA |\ SUPPORT_SEEK | SUPPORT_CLEAR_PLAYLIST | SUPPORT_SELECT_SOURCE SERVICE_GROUP_PLAYERS = 'sonos_group_players' SERVICE_UNJOIN = 'sonos_unjoin' SERVICE_SNAPSHOT = 'sonos_snapshot' SERVICE_RESTORE = 'sonos_restore' SERVICE_SET_TIMER = 'sonos_set_sleep_timer' SERVICE_CLEAR_TIMER = 'sonos_clear_sleep_timer' SUPPORT_SOURCE_LINEIN = 'Line-in' SUPPORT_SOURCE_TV = 'TV' # Service call validation schemas ATTR_SLEEP_TIME = 'sleep_time' SONOS_SCHEMA = vol.Schema({ ATTR_ENTITY_ID: cv.entity_ids, }) SONOS_SET_TIMER_SCHEMA = SONOS_SCHEMA.extend({ vol.Required(ATTR_SLEEP_TIME): vol.All(vol.Coerce(int), vol.Range(min=0, max=86399)) }) # List of devices that have been registered DEVICES = [] def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Sonos platform.""" import soco global DEVICES if discovery_info: player = soco.SoCo(discovery_info) # if device allready exists by config if player.uid in DEVICES: return True if player.is_visible: device = SonosDevice(hass, player) add_devices([device], True) if not DEVICES: register_services(hass) DEVICES.append(device) return True return False players = None hosts = config.get('hosts', None) if hosts: # Support retro compatibility with comma separated list of hosts # from config hosts = hosts.split(',') if isinstance(hosts, str) else hosts players = [] for host in hosts: players.append(soco.SoCo(socket.gethostbyname(host))) if not players: players = soco.discover(interface_addr=config.get('interface_addr', None)) if not players: _LOGGER.warning('No Sonos speakers found.') return False DEVICES = [SonosDevice(hass, p) for p in players] add_devices(DEVICES, True) register_services(hass) _LOGGER.info('Added %s Sonos speakers', len(players)) return True def register_services(hass): """Register all services for sonos devices.""" descriptions = load_yaml_config_file( path.join(path.dirname(__file__), 'services.yaml')) hass.services.register(DOMAIN, SERVICE_GROUP_PLAYERS, _group_players_service, descriptions.get(SERVICE_GROUP_PLAYERS), schema=SONOS_SCHEMA) hass.services.register(DOMAIN, SERVICE_UNJOIN, _unjoin_service, descriptions.get(SERVICE_UNJOIN), schema=SONOS_SCHEMA) hass.services.register(DOMAIN, SERVICE_SNAPSHOT, _snapshot_service, descriptions.get(SERVICE_SNAPSHOT), schema=SONOS_SCHEMA) hass.services.register(DOMAIN, SERVICE_RESTORE, _restore_service, descriptions.get(SERVICE_RESTORE), schema=SONOS_SCHEMA) hass.services.register(DOMAIN, SERVICE_SET_TIMER, _set_sleep_timer_service, descriptions.get(SERVICE_SET_TIMER), schema=SONOS_SET_TIMER_SCHEMA) hass.services.register(DOMAIN, SERVICE_CLEAR_TIMER, _clear_sleep_timer_service, descriptions.get(SERVICE_CLEAR_TIMER), schema=SONOS_SCHEMA) def _apply_service(service, service_func, *service_func_args): """Internal func for applying a service.""" entity_ids = service.data.get('entity_id') if entity_ids: _devices = [device for device in DEVICES if device.entity_id in entity_ids] else: _devices = DEVICES for device in _devices: service_func(device, *service_func_args) device.update_ha_state(True) def _group_players_service(service): """Group media players, use player as coordinator.""" _apply_service(service, SonosDevice.group_players) def _unjoin_service(service): """Unjoin the player from a group.""" _apply_service(service, SonosDevice.unjoin) def _snapshot_service(service): """Take a snapshot.""" _apply_service(service, SonosDevice.snapshot) def _restore_service(service): """Restore a snapshot.""" _apply_service(service, SonosDevice.restore) def _set_sleep_timer_service(service): """Set a timer.""" _apply_service(service, SonosDevice.set_sleep_timer, service.data[ATTR_SLEEP_TIME]) def _clear_sleep_timer_service(service): """Set a timer.""" _apply_service(service, SonosDevice.clear_sleep_timer) def only_if_coordinator(func): """Decorator for coordinator. If used as decorator, avoid calling the decorated method if player is not a coordinator. If not, a grouped speaker (not in coordinator role) will throw soco.exceptions.SoCoSlaveException. Also, partially catch exceptions like: soco.exceptions.SoCoUPnPException: UPnP Error 701 received: Transition not available from """ def wrapper(*args, **kwargs): """Decorator wrapper.""" if args[0].is_coordinator: from soco.exceptions import SoCoUPnPException try: func(*args, **kwargs) except SoCoUPnPException: _LOGGER.error('command "%s" for Sonos device "%s" ' 'not available in this mode', func.__name__, args[0].name) else: _LOGGER.debug('Ignore command "%s" for Sonos device "%s" (%s)', func.__name__, args[0].name, 'not coordinator') return wrapper def _parse_timespan(timespan): """Parse a time-span into number of seconds.""" if timespan in ('', 'NOT_IMPLEMENTED', None): return None else: return sum(60 ** x[0] * int(x[1]) for x in enumerate( reversed(timespan.split(':')))) class _ProcessSonosEventQueue(): """Queue like object for dispatching sonos events.""" def __init__(self, sonos_device): self._sonos_device = sonos_device def put(self, item, block=True, timeout=None): """Queue up event for processing.""" # Instead of putting events on a queue, dispatch them to the event # processing method. self._sonos_device.process_sonos_event(item) class SonosDevice(MediaPlayerDevice): """Representation of a Sonos device.""" def __init__(self, hass, player): """Initialize the Sonos device.""" from soco.snapshot import Snapshot self.hass = hass self.volume_increment = 5 self._unique_id = player.uid self._player = player self._player_volume = None self._player_volume_muted = None self._speaker_info = None self._name = None self._status = None self._coordinator = None self._media_content_id = None self._media_duration = None self._media_image_url = None self._media_artist = None self._media_album_name = None self._media_title = None self._media_radio_show = None self._media_next_title = None self._support_previous_track = False self._support_next_track = False self._support_pause = False self._current_track_uri = None self._current_track_is_radio_stream = False self._queue = None self._last_avtransport_event = None self._is_playing_line_in = None self._is_playing_tv = None self.soco_snapshot = Snapshot(self._player) @property def should_poll(self): """Polling needed.""" return True @property def unique_id(self): """Return an unique ID.""" return self._unique_id @property def name(self): """Return the name of the device.""" return self._name @property def state(self): """Return the state of the device.""" if self._coordinator: return self._coordinator.state if self._status in ('PAUSED_PLAYBACK', 'STOPPED'): return STATE_PAUSED if self._status in ('PLAYING', 'TRANSITIONING'): return STATE_PLAYING if self._status == 'OFF': return STATE_OFF return STATE_IDLE @property def is_coordinator(self): """Return true if player is a coordinator.""" return self._coordinator is None def _is_available(self): try: sock = socket.create_connection( address=(self._player.ip_address, 1443), timeout=3) sock.close() return True except socket.error: return False # pylint: disable=invalid-name def _subscribe_to_player_events(self): if self._queue is None: self._queue = _ProcessSonosEventQueue(self) self._player.avTransport.subscribe( auto_renew=True, event_queue=self._queue) self._player.renderingControl.subscribe( auto_renew=True, event_queue=self._queue) # pylint: disable=too-many-branches, too-many-statements def update(self): """Retrieve latest state.""" if self._speaker_info is None: self._speaker_info = self._player.get_speaker_info(True) self._name = self._speaker_info['zone_name'].replace( ' (R)', '').replace(' (L)', '') if self._last_avtransport_event: is_available = True else: is_available = self._is_available() if is_available: self._is_playing_tv = self._player.is_playing_tv self._is_playing_line_in = self._player.is_playing_line_in track_info = None if self._last_avtransport_event: variables = self._last_avtransport_event.variables current_track_metadata = variables.get( 'current_track_meta_data', {} ) self._status = variables.get('transport_state') if current_track_metadata: # no need to ask speaker for information we already have current_track_metadata = current_track_metadata.__dict__ track_info = { 'uri': variables.get('current_track_uri'), 'artist': current_track_metadata.get('creator'), 'album': current_track_metadata.get('album'), 'title': current_track_metadata.get('title'), 'playlist_position': variables.get('current_track'), 'duration': variables.get('current_track_duration') } else: self._player_volume = self._player.volume self._player_volume_muted = self._player.mute transport_info = self._player.get_current_transport_info() self._status = transport_info.get('current_transport_state') if not track_info: track_info = self._player.get_current_track_info() if track_info['uri'].startswith('x-rincon:'): # this speaker is a slave, find the coordinator # the uri of the track is 'x-rincon:{coordinator-id}' coordinator_id = track_info['uri'][9:] coordinators = [device for device in DEVICES if device.unique_id == coordinator_id] self._coordinator = coordinators[0] if coordinators else None else: self._coordinator = None if not self._coordinator: media_info = self._player.avTransport.GetMediaInfo( [('InstanceID', 0)] ) current_media_uri = media_info['CurrentURI'] media_artist = track_info.get('artist') media_album_name = track_info.get('album') media_title = track_info.get('title') is_radio_stream = \ current_media_uri.startswith('x-sonosapi-stream:') or \ current_media_uri.startswith('x-rincon-mp3radio:') if is_radio_stream: is_radio_stream = True media_image_url = self._format_media_image_url( current_media_uri ) support_previous_track = False support_next_track = False support_pause = False # for radio streams we set the radio station name as the # title. if media_artist and media_title: # artist and album name are in the data, concatenate # that do display as artist. # "Information" field in the sonos pc app media_artist = '{artist} - {title}'.format( artist=media_artist, title=media_title ) else: # "On Now" field in the sonos pc app media_artist = self._media_radio_show current_uri_metadata = media_info["CurrentURIMetaData"] if current_uri_metadata not in \ ('', 'NOT_IMPLEMENTED', None): # currently soco does not have an API for this import soco current_uri_metadata = soco.xml.XML.fromstring( soco.utils.really_utf8(current_uri_metadata)) md_title = current_uri_metadata.findtext( './/{http://purl.org/dc/elements/1.1/}title') if md_title not in ('', 'NOT_IMPLEMENTED', None): media_title = md_title if media_artist and media_title: # some radio stations put their name into the artist # name, e.g.: # media_title = "Station" # media_artist = "Station - Artist - Title" # detect this case and trim from the front of # media_artist for cosmetics str_to_trim = '{title} - '.format( title=media_title ) chars = min(len(media_artist), len(str_to_trim)) if media_artist[:chars].upper() == \ str_to_trim[:chars].upper(): media_artist = media_artist[chars:] else: # not a radio stream media_image_url = self._format_media_image_url( track_info['uri'] ) support_previous_track = True support_next_track = True support_pause = True playlist_position = track_info.get('playlist_position') if playlist_position in ('', 'NOT_IMPLEMENTED', None): playlist_position = None else: playlist_position = int(playlist_position) playlist_size = media_info.get('NrTracks') if playlist_size in ('', 'NOT_IMPLEMENTED', None): playlist_size = None else: playlist_size = int(playlist_size) if playlist_position is not None and \ playlist_size is not None: if playlist_position == 1: support_previous_track = False if playlist_position == playlist_size: support_next_track = False self._media_content_id = track_info.get('title') self._media_duration = _parse_timespan( track_info.get('duration') ) self._media_image_url = media_image_url self._media_artist = media_artist self._media_album_name = media_album_name self._media_title = media_title self._current_track_uri = track_info['uri'] self._current_track_is_radio_stream = is_radio_stream self._support_previous_track = support_previous_track self._support_next_track = support_next_track self._support_pause = support_pause # update state of the whole group # pylint: disable=protected-access for device in [x for x in DEVICES if x._coordinator == self]: if device.entity_id is not self.entity_id: self.hass.add_job(device.async_update_ha_state) if self._queue is None: self._subscribe_to_player_events() else: self._player_volume = None self._player_volume_muted = None self._status = 'OFF' self._coordinator = None self._media_content_id = None self._media_duration = None self._media_image_url = None self._media_artist = None self._media_album_name = None self._media_title = None self._media_radio_show = None self._media_next_title = None self._current_track_uri = None self._current_track_is_radio_stream = False self._support_previous_track = False self._support_next_track = False self._support_pause = False self._is_playing_tv = False self._is_playing_line_in = False self._last_avtransport_event = None def _format_media_image_url(self, uri): return 'http://{host}:{port}/getaa?s=1&u={uri}'.format( host=self._player.ip_address, port=1400, uri=urllib.parse.quote(uri) ) def process_sonos_event(self, event): """Process a service event coming from the speaker.""" next_track_image_url = None if event.service == self._player.avTransport: self._last_avtransport_event = event self._media_radio_show = None if self._current_track_is_radio_stream: current_track_metadata = event.variables.get( 'current_track_meta_data' ) if current_track_metadata: self._media_radio_show = \ current_track_metadata.radio_show.split(',')[0] next_track_uri = event.variables.get('next_track_uri') if next_track_uri: next_track_image_url = self._format_media_image_url( next_track_uri ) next_track_metadata = event.variables.get('next_track_meta_data') if next_track_metadata: next_track = '{title} - {creator}'.format( title=next_track_metadata.title, creator=next_track_metadata.creator ) if next_track != self._media_next_title: self._media_next_title = next_track else: self._media_next_title = None elif event.service == self._player.renderingControl: if 'volume' in event.variables: self._player_volume = int( event.variables['volume'].get('Master') ) if 'mute' in event.variables: self._player_volume_muted = \ event.variables['mute'].get('Master') == '1' self.update_ha_state(True) if next_track_image_url: self.preload_media_image_url(next_track_image_url) @property def volume_level(self): """Volume level of the media player (0..1).""" return self._player_volume / 100.0 @property def is_volume_muted(self): """Return true if volume is muted.""" return self._player_volume_muted @property def media_content_id(self): """Content ID of current playing media.""" if self._coordinator: return self._coordinator.media_content_id else: return self._media_content_id @property def media_content_type(self): """Content type of current playing media.""" return MEDIA_TYPE_MUSIC @property def media_duration(self): """Duration of current playing media in seconds.""" if self._coordinator: return self._coordinator.media_duration else: return self._media_duration @property def media_image_url(self): """Image url of current playing media.""" if self._coordinator: return self._coordinator.media_image_url else: return self._media_image_url @property def media_artist(self): """Artist of current playing media, music track only.""" if self._coordinator: return self._coordinator.media_artist else: return self._media_artist @property def media_album_name(self): """Album name of current playing media, music track only.""" if self._coordinator: return self._coordinator.media_album_name else: return self._media_album_name @property def media_title(self): """Title of current playing media.""" if self._coordinator: return self._coordinator.media_title else: return self._media_title @property def supported_media_commands(self): """Flag of media commands that are supported.""" if self._coordinator: return self._coordinator.supported_media_commands supported = SUPPORT_SONOS if not self.source_list: # some devices do not allow source selection supported = supported ^ SUPPORT_SELECT_SOURCE if not self._support_previous_track: supported = supported ^ SUPPORT_PREVIOUS_TRACK if not self._support_next_track: supported = supported ^ SUPPORT_NEXT_TRACK if not self._support_pause: supported = supported ^ SUPPORT_PAUSE return supported def volume_up(self): """Volume up media player.""" self._player.volume += self.volume_increment def volume_down(self): """Volume down media player.""" self._player.volume -= self.volume_increment def set_volume_level(self, volume): """Set volume level, range 0..1.""" self._player.volume = str(int(volume * 100)) def mute_volume(self, mute): """Mute (true) or unmute (false) media player.""" self._player.mute = mute def select_source(self, source): """Select input source.""" if source == SUPPORT_SOURCE_LINEIN: self._player.switch_to_line_in() elif source == SUPPORT_SOURCE_TV: self._player.switch_to_tv() @property def source_list(self): """List of available input sources.""" model_name = self._speaker_info['model_name'] if 'PLAY:5' in model_name: return [SUPPORT_SOURCE_LINEIN] elif 'PLAYBAR' in model_name: return [SUPPORT_SOURCE_LINEIN, SUPPORT_SOURCE_TV] @property def source(self): """Name of the current input source.""" if self._is_playing_line_in: return SUPPORT_SOURCE_LINEIN if self._is_playing_tv: return SUPPORT_SOURCE_TV return None def turn_off(self): """Turn off media player.""" self.media_pause() def media_play(self): """Send play command.""" if self._coordinator: self._coordinator.media_play() else: self._player.play() def media_pause(self): """Send pause command.""" if self._coordinator: self._coordinator.media_pause() else: self._player.pause() def media_next_track(self): """Send next track command.""" if self._coordinator: self._coordinator.media_next_track() else: self._player.next() def media_previous_track(self): """Send next track command.""" if self._coordinator: self._coordinator.media_previous_track() else: self._player.previous() def media_seek(self, position): """Send seek command.""" if self._coordinator: self._coordinator.media_seek(position) else: self._player.seek(str(datetime.timedelta(seconds=int(position)))) def clear_playlist(self): """Clear players playlist.""" if self._coordinator: self._coordinator.clear_playlist() else: self._player.clear_queue() def turn_on(self): """Turn the media player on.""" self.media_play() def play_media(self, media_type, media_id, **kwargs): """ Send the play_media command to the media player. If ATTR_MEDIA_ENQUEUE is True, add `media_id` to the queue. """ if self._coordinator: self._coordinator.play_media(media_type, media_id, **kwargs) else: if kwargs.get(ATTR_MEDIA_ENQUEUE): from soco.exceptions import SoCoUPnPException try: self._player.add_uri_to_queue(media_id) except SoCoUPnPException: _LOGGER.error('Error parsing media uri "%s", ' "please check it's a valid media resource " 'supported by Sonos', media_id) else: self._player.play_uri(media_id) def group_players(self): """Group all players under this coordinator.""" if self._coordinator: self._coordinator.group_players() else: self._player.partymode() @only_if_coordinator def unjoin(self): """Unjoin the player from a group.""" self._player.unjoin() @only_if_coordinator def snapshot(self): """Snapshot the player.""" self.soco_snapshot.snapshot() @only_if_coordinator def restore(self): """Restore snapshot for the player.""" self.soco_snapshot.restore(True) @only_if_coordinator def set_sleep_timer(self, sleep_time): """Set the timer on the player.""" self._player.set_sleep_timer(sleep_time) @only_if_coordinator def clear_sleep_timer(self): """Clear the timer on the player.""" self._player.set_sleep_timer(None)