def do(self, params): speaker = SoCo(socket.gethostbyname(params['host'])) print(speaker.groups) if 'volume' in params: speaker.volume = params['volume'] if 'clear_queue' in params: speaker.clear_queue() if 'add_playlist_id_to_queue' in params: playlist = speaker.get_sonos_playlists()[ params['add_playlist_id_to_queue']] speaker.add_uri_to_queue(playlist.resources[0].uri) if 'switch_to_tv' in params: speaker.switch_to_tv() if 'next' in params: speaker.next() elif 'previous' in params: speaker.previous() if 'play' in params: speaker.play() elif 'pause' in params: speaker.pause() if 'set_sleep_timer' in params: speaker.set_sleep_timer(params['set_sleep_timer'] * 60)
def bttn_stop(): # connect to the Sonos sonos = SoCo(SONOS_IP) # connect to Philips Hue Bridge hue = Bridge(ip=HUE_IP, username=HUE_USERNAME) # stop the Sonos and reset to sensible defaults queue = sonos.get_queue() sonos.clear_queue() sonos.volume = 45 sonos.play_mode = 'NORMAL' sonos.stop() # set the lights back to approximately 80% over 3 seconds command = { 'transitiontime': 30, 'on': True, 'bri': 203 } hue.set_light(1, command) return jsonify(status="success")
def bttn_stop(): # connect to the Sonos sonos = SoCo(SONOS_IP) # connect to Philips Hue Bridge hue = Bridge(ip=HUE_IP, username=HUE_USERNAME) # stop the Sonos and reset to sensible defaults queue = sonos.get_queue() sonos.clear_queue() sonos.volume = STOP_VOLUME sonos.play_mode = 'NORMAL' sonos.stop() # set the lights back to a sensible default command = { 'transitiontime': (STOP_DIMMER_SECONDS * 10), 'on': True, 'bri': STOP_DIMMER_BRIGHTNESS } hue.set_light(STOP_LIGHTS, command) return jsonify(status="success")
def play_spot(junk, location): time.sleep(5) play_room = (str(pod_dict['Rooms']['Living'])) sonos = SoCo(play_room) uri = location['location'] sonos.clear_queue() sonos.add_uri_to_queue(uri=uri) sonos.play_from_queue(index=0) sonos.play_mode = "SHUFFLE_NOREPEAT"
def sexy_time(): # connect to the Sonos sonos = SoCo(SONOS_IP) # connect to Philips Hue Bridge hue = Bridge(ip=HUE_IP, username=HUE_USERNAME) # get queue queue = sonos.get_queue() # if we: # * already have a queue # * music is playing # * we are already playing a queue that begins with "Let's Get It On" # ...then skip to the next track if len(queue) > 0 and \ sonos.get_current_transport_info()['current_transport_state'] == "PLAYING" and \ queue[0].title == SEXY_TIME_FIRST_TRACK: sonos.next() # else, intitiate a fresh Sexy Time else: # clear Sonos queue sonos.clear_queue() # turn off shuffle and repeat sonos.play_mode = 'NORMAL' # set volume sonos.volume = 45 # play Sexy Time playlist playlist = get_sonos_playlist(sonos, SEXY_TIME_PLAYLIST_NAME) if playlist: sonos.add_to_queue(playlist) sonos.play() # dim the lights (bri out of 254) over the pre-defined amount of time command = { 'transitiontime': (SEXY_TIME_DIMMER_SECONDS * 10), 'on': True, 'bri': SEXY_TIME_DIMMER_BRIGHTNESS } hue.set_light(1, command) return jsonify(status="success")
class SonoController(): def __init__(self, ip): self.core = SoCo(ip) def play_uri(self, url): self.core.play_uri(url) def play_by_userName(self, name): url = URL_BASE.get(name, "Unknown") if (url == "Unknown"): track = self.core.get_current_track_info() current_play = track['title'] # print track['title'] target_play = MUSIC_BASE.get(url, "Unknow") # print target_play if (current_play == target_play): print "unknown person" else: self.core.clear_queue() self.core.add_uri_to_queue(ALARM_URL) self.core.add_uri_to_queue(END_URL) self.core.play_from_queue(0, True) else: track = self.core.get_current_track_info() current_play = track['title'] # print track['title'] target_play = MUSIC_BASE.get(url, "Unknow") # print target_play if (current_play == target_play): print "the same person" else: self.core.clear_queue() self.core.add_uri_to_queue(url) self.core.add_uri_to_queue(END_URL) self.core.play_from_queue(0, True) def pause(self): self.core.pause() def mute(self): self.core.mute = True def unMute(self): self.core.mute = False def setVolume(self, val): self.core.volume = val def alarm(self): self.play_uri(ALARM_URL) time.sleep(8.0) self.pause()
def playTheme(themes, sonosPlayer): sonos = SoCo(sonosPlayer) #syslog.syslog('%s' % str(sonos.get_current_track_info())) #return ''; if playerPlays(sonos): syslog.syslog('Already playing') return ''; sonos.unjoin() sonos.clear_queue() sonos.add_uri_to_queue(themes['closer']) sonos.play_mode = 'REPEAT_ALL' syslog.syslog('%s' % sonos.play_mode) sonos.volume = 5; if playerPlays(sonos): return ''; sonos.play() syslog.syslog('Playing Closer')
def arriving_home(): # connect to Philips Hue Bridge hue = Bridge(ip=HUE_IP, username=HUE_USERNAME) # set the lights to approximately 80% over 3 seconds command = { 'transitiontime': 30, 'on': True, 'bri': 203 } hue.set_light(1, command) # connect to the Sonos sonos = SoCo(SONOS_IP) # clear the queue sonos.clear_queue() # set volume sonos.volume = 25 # play Arriving Home playlist playlist = get_sonos_playlist(sonos, ARRIVING_HOME_PLAYLIST_NAME) print playlist if playlist: sonos.add_to_queue(playlist) # turn on shuffle, turn off repeat sonos.play_mode = 'SHUFFLE_NOREPEAT' # play sonos.play() # we're in shuffle mode, but the first track is always the same sonos.next() return jsonify(status="success")
def sonos_clear_queue(self): """sonos_clear_queue, maak sonos afspeellijst leeg """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_clear_queue() ## queue leegmaken als er wat in zit sonos = SoCo(COORDINATOR) # als de sonos queue niet leeg is if len(sonos.get_queue()) > 0: ## sonos queue leegmaken sonos.clear_queue() query = """ delete from queue """ self._db.dbExecute(query) return h
def arriving_home(): # connect to Philips Hue Bridge hue = Bridge(ip=HUE_IP, username=HUE_USERNAME) # set the lights to appropriate brightness over appropriate time command = { 'transitiontime': (ARRIVING_HOME_DIMMER_SECONDS * 10), 'on': True, 'bri': ARRIVING_HOME_DIMMER_BRIGHTNESS } hue.set_light(ARRIVING_HOME_LIGHTS, command) # connect to the Sonos sonos = SoCo(SONOS_IP) # clear the queue sonos.clear_queue() # set volume sonos.volume = ARRIVING_HOME_VOLUME # play Arriving Home playlist playlist = get_sonos_playlist(sonos, ARRIVING_HOME_PLAYLIST_NAME) if playlist: sonos.add_to_queue(playlist) # turn on shuffle, turn off repeat sonos.play_mode = 'SHUFFLE_NOREPEAT' # play sonos.play() # we're in shuffle mode, but the first track is always the same sonos.next() return jsonify(status="success")
def play(self, playlist, location, play_mode): print("PLAY MODE: " + str(play_mode)) if playlist not in self.playlists.keys(): self.playlists = dict() for favorite in self.sonos.music_library.get_sonos_favorites(): self.playlists[favorite.title] = favorite.reference try: for speaker in location: if speaker not in self.ips: self.ips = self.music_repository.get_ip(speaker) print("Playing on Speaker with IP Address: " + self.ips[speaker]) sonos = SoCo(self.ips[speaker]) sonos.clear_queue() sonos.add_to_queue(self.playlists[playlist]) if play_mode is not None: sonos.play_mode = play_mode else: sonos.play_mode = 'NORMAL' sonos.play_from_queue(0) except KeyError: print("Trouble with Playlist: {}, Location {}, Play_Mode: {}".format(playlist, location, play_mode))
def party(): # connect to the Sonos sonos = SoCo(SONOS_IP) # get queue queue = sonos.get_queue() # if we: # * already have a queue # * music is playing # ...then skip to the next track if len(queue) > 0 and sonos.get_current_transport_info()['current_transport_state'] == "PLAYING": sonos.next() # else, intitiate a fresh Party Time else: # clear Sonos queue sonos.clear_queue() # turn on shuffle, turn off repeat sonos.play_mode = 'SHUFFLE_NOREPEAT' # set volume sonos.volume = 45 # play Party playlist playlist = get_sonos_playlist(sonos, PARTY_TIME_PLAYLIST_NAME) if playlist: sonos.add_to_queue(playlist) sonos.play() return jsonify(status="success")
class Component(ThreadComponent): MATRIX = matrices.MUSIC_NOTE STATE_PLAYING = 'PLAYING' STATE_PAUSED = 'PAUSED_PLAYBACK' STATE_STOPPED = 'STOPPED' # how many seconds to wait after sending last command before # receiving device state change events EVENT_IDLE_INTERVAL = 2 # seconds def __init__(self, component_config): super().__init__(component_config) self.sonos_controller = SoCo(component_config['ip_address']) self.volume_range = range(0, 100) self.event_listener = event_listener # comes from global scope self.state = None self.volume = None self.nuimo = None self.last_request_time = time() self.sonos_joined_controllers = [] self.station_id_1 = component_config.get('station1', None) self.station_id_2 = component_config.get('station2', None) self.station_id_3 = component_config.get('station3', None) if not any((self.station_id_1, self.station_id_2, self.station_id_3)): try: favorites = self.sonos_controller.get_sonos_favorites( max_items=3) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) if favorites['returned'] >= 3: self.station_id_1 = favorites['favorites'][0] self.station_id_2 = favorites['favorites'][1] self.station_id_3 = favorites['favorites'][2] if len( self.sonos_controller.group.members ) > 1 and self.sonos_controller.group.coordinator.ip_address == component_config[ 'ip_address']: for sonos_controller in self.sonos_controller.group.members: if sonos_controller.ip_address != component_config[ 'ip_address'] and sonos_controller.player_name != self.sonos_controller.group.coordinator.player_name: self.sonos_joined_controllers.append( SoCo(sonos_controller.ip_address)) def run(self): self.subscribe_to_events() self.update_state() try: self.run_loop() finally: self.unsubscribe_from_events() def run_loop(self): while not self.stopped: try: event = self.av_transport_subscription.events.get(timeout=0.1) if time() - self.last_request_time > self.EVENT_IDLE_INTERVAL: logger.debug("avTransport event: %s", pformat(event.variables)) self.state = event.variables['transport_state'] except Empty: pass try: event = self.rendering_control_subscription.events.get( timeout=0.1) if time() - self.last_request_time > self.EVENT_IDLE_INTERVAL: logger.debug("renderingControl event: %s", pformat(event.variables)) self.volume = int(event.variables['volume']['Master']) except Empty: pass def subscribe_to_events(self): self.av_transport_subscription = self.sonos_controller.avTransport.subscribe( ) self.rendering_control_subscription = self.sonos_controller.renderingControl.subscribe( ) def unsubscribe_from_events(self): self.rendering_control_subscription.unsubscribe() self.av_transport_subscription.unsubscribe() def update_state(self): self.state = self.sonos_controller.get_current_transport_info( )['current_transport_state'] self.volume = self.sonos_controller.volume logger.debug("%s state: %s volume: %s", self.sonos_controller.ip_address, self.state, self.volume) def on_rotation(self, delta): if self.state is not None: try: delta = round(self.volume_range.stop * delta) self.volume = clamp_value(self.volume + delta, self.volume_range) self.sonos_controller.volume = self.volume if self.sonos_joined_controllers != []: for sonos_joined_controller in self.sonos_joined_controllers: sonos_joined_controller.volume = self.volume logger.debug("volume update delta: %s volume: %s", delta, self.volume) matrix = matrices.progress_bar(self.volume / self.volume_range.stop) self.nuimo.display_matrix(matrix, fading=True, ignore_duplicates=True) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) self.last_request_time = time() else: self.nuimo.display_matrix(matrices.ERROR) logger.debug("No Active connection with Host") def on_button_press(self): if self.state == self.STATE_PLAYING: self.pause() logger.debug("Play Paused by self.pause() on button press.") elif self.state in [self.STATE_PAUSED, self.STATE_STOPPED]: self.play() logger.debug( "Play started/resumed by self.pause() on button press.") elif self.state is None: self.nuimo.display_matrix(matrices.ERROR) logger.debug("No Active connection with Host.") logger.debug("state toggle: %s", self.state) self.last_request_time = time() def pause(self, show_matrix=True): try: self.sonos_controller.pause() self.state = self.STATE_PAUSED if show_matrix: self.nuimo.display_matrix(matrices.PAUSE) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def play(self, show_matrix=True): try: self.sonos_controller.play() self.state = self.STATE_PLAYING if show_matrix: self.nuimo.display_matrix(matrices.PLAY) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def on_swipe_right(self): try: self.sonos_controller.next() if self.state != self.STATE_PLAYING: self.play(show_matrix=False) self.nuimo.display_matrix(matrices.NEXT_SONG) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) self.last_request_time = time() def on_swipe_left(self): try: self.sonos_controller.previous() if self.state != self.STATE_PLAYING: self.play(show_matrix=False) self.nuimo.display_matrix(matrices.PREVIOUS_SONG) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) self.last_request_time = time() def on_longtouch_left(self): logger.debug("favorite left") if self.station_id_1 is not None: try: self.play_track_playlist_or_album(self.station_id_1, matrices.STATION1) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def on_longtouch_bottom(self): logger.debug("favorite bottom") if self.station_id_2 is not None: try: self.play_track_playlist_or_album(self.station_id_2, matrices.STATION2) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def on_longtouch_right(self): logger.debug("favorite right") if self.station_id_3 is not None: try: self.play_track_playlist_or_album(self.station_id_3, matrices.STATION3) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def play_track_playlist_or_album(self, src, matrix): try: if 'object.container.playlistContainer' in src[ 'meta'] or 'object.container.album.musicAlbum' in src[ 'meta']: self._replace_queue_with_playlist(src) self.sonos_controller.play_from_queue(0) else: self.sonos_controller.play_uri(uri=src['uri'], meta=src['meta'], title=src['title']) self.nuimo.display_matrix(matrix) except SoCoException: self.nuimo.display_matrix(matrices.ERROR) def _replace_queue_with_playlist(self, src): """Replace queue with playlist represented by src. Playlists can't be played directly with the self.sonos_controller.play_uri API as they are actually composed of mulitple URLs. Until soco has suppport for playing a playlist, we'll need to parse the playlist item and replace the current queue in order to play it. """ import soco import xml.etree.ElementTree as ET root = ET.fromstring(src['meta']) namespaces = { 'item': 'urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/', 'desc': 'urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/' } desc = root.find('item:item', namespaces).find('desc:desc', namespaces).text res = [ soco.data_structures.DidlResource(uri=src['uri'], protocol_info="DUMMY") ] didl = soco.data_structures.DidlItem(title="DUMMY", parent_id="DUMMY", item_id=src['uri'], desc=desc, resources=res) self.sonos_controller.stop() self.sonos_controller.clear_queue() self.sonos_controller.play_mode = 'NORMAL' self.sonos_controller.add_to_queue(didl)
#import the the sonos controller library and datetime library from soco import SoCo import datetime #set player variable to a sonos speaker - speaker set with static IP player = SoCo('192.168.1.15') #set comparison variable now = datetime.datetime.now() #cron script will run this program at 10pm everynight and 830 am every morning #for night time, play the sleep music playlist if now.hour == 22 and now.minute == 0: #clear the song queue player.clear_queue() #set playlist variable to sonos playlist #night time music is the 5th one - want to update this to search for playlist by name #playlist = player.get_sonos_playlists()[2] playlist = player.get_sonos_playlists()[4] #add playlist to sonos speaker queue player.add_to_queue(playlist) #play from queue method with index as arg player.play() #if it's morning, stop the sleep music if now.hour == 8 and now.minute == 30: player.stop()