def volume_down(self, location): for speaker in location: if speaker not in self.ips: self.ips = self.music_repository.get_ip(speaker) print("Lowering Volume on Speaker with IP Address: " + self.ips[speaker]) sonos = SoCo(self.ips[speaker]) sonos.set_relative_volume(-1)
def now_playing(self): my_zone = SoCo('192.168.86.225') status = my_zone.get_current_transport_info() track = my_zone.get_current_track_info() artist = '' title = '' if(track['artist'] == '' and track['title'] == ''): return "Stopped - Playlist Empty" elif (track['artist'] == '' and track['title'] != ''): title = track['title'] parts = title.split('|') for part in parts: if(part[:7] == 'ARTIST '): artist = part[7:] elif(part[:6] == 'TITLE '): title = part[6:] else: artist = track['artist'] title = track['title'] state = "Now Playing: " if(status['current_transport_state'] == 'STOPPED'): state = "Up Next" return state + artist + ' - ' + title
def main(): speakers = [speaker.ip_address for speaker in SoCo.discover()] if not speakers: print("no speakers found, exiting.") return soco = SoCo(speakers[0]) # get a plugin by name (eg from a config file) myplugin = SoCoPlugin.from_name("soco.plugins.example.ExamplePlugin", soco, "some user") # do something with your plugin print("Testing", myplugin.name) myplugin.music_plugin_play() time.sleep(5) # create a plugin by normal instantiation from soco.plugins.example import ExamplePlugin # create a new plugin, pass the soco instance to it myplugin = ExamplePlugin(soco, "a user") print("Testing", myplugin.name) # do something with your plugin myplugin.music_plugin_stop()
class Sonos(AbstractJob): def __init__(self, conf): self.interval = conf['interval'] self.sonos = SoCo(conf['ip']) def get(self): zone_name = self.sonos.get_speaker_info()['zone_name'] np = self.sonos.get_current_track_info() current_track = np if np['playlist_position'] != '0' else None queue = self.sonos.get_queue(int(np['playlist_position']), 1) next_item = queue.pop() if len(queue) > 0 else None next_track = {} if next_item is not None: next_track = { 'artist': next_item.creator, 'title': next_item.title, 'album': next_item.album } state = self.sonos.get_current_transport_info()[ 'current_transport_state'] return { 'room': zone_name, 'state': state, 'current': current_track, 'next': next_track }
def play_sonos(junk): logging.info('play button pressed') self.force_refresh = True self.nav_array[int(right(junk.label, 1)) - 1] = BoxButton( 'pause', 2, is_sprite=True, theme=nav_theme, on_press=pause_sonos, user_data=None) #self.nav_grid = urwid.GridFlow(self.nav_array,cell_width=50,h_sep=0,v_sep=0,align='center') self.dead_alarm = self.loop.set_alarm_in(.01, self.refresh) #commented out for testing at hotel play_room = (str(pod_dict['Rooms']['Living'])) try: sonos = SoCo(play_room) look_at_queue = sonos.get_queue() if len(look_at_queue) > 0: sonos.group.coordinator.play() #else: # print("the queue is empty") except: #this doesn't work for some reason. try just looking for stop states. logging.warning("Exception caught. Not expecting trace", exc_info=False, stack_info=False) print("the queue is empty")
def add_to_group(spkr_ip, coord_ip): my_soco = SoCo(spkr_ip) ans = [] if my_soco is not None: my_soco.join(SoCo(coord_ip)) return ans
def play_uri(ip, uri, meta): my_soco = SoCo(ip) ans = [] if my_soco is not None: my_soco.play_uri(uri, meta) return ans
def play_fav(title, uri, meta, ip): my_soco = SoCo(ip) ans = [] if my_soco is not None: my_soco.play_uri(uri, meta, title) return ans
def play_sonos(junk): logging.info('pause button pressed, start playing') self.force_refresh = True self.nav_array[1] = BoxButton('pause', 2, is_sprite=True, on_press=play_sonos, user_data=None) #self.nav_grid = urwid.GridFlow(self.nav_array,cell_width=50,h_sep=0,v_sep=0,align='center') self.dead_alarm = self.loop.set_alarm_in(.01, self.refresh) #commented out for testing at hotel play_room = (str(pod_dict['Rooms']['Living'])) self.poor_man_refresh() try: sonos = SoCo(play_room) look_at_queue = sonos.get_queue() if len(look_at_queue) > 0: sonos.group.coordinator.play() else: print("the queue is empty") except soco.exceptions.SoCoUPnPException as e: logging.warning("Exception caught. Not expecting trace", exc_info=False, stack_info=False) print("the queue is empty")
def get_zone(zone_name): device = SoCo('192.168.1.253') return device cache_name = "{}_last_known_ip.txt".format(zone_name) if devices: for device in devices: if device.player_name == zone_name: # Save the well known IP of the device for future cache # When discover() fails need to fallback to this solution #try: f = open(cache_name, "w+") f.write(device.ip_address) f.close() return device # Device not found, try be known IP try: if os.path.isfile(cache_name) and os.access(cache_name, os.R_OK): f = open(cache_name, "r") ip_address = f.readline() f.close() print("Using cached IP:{} for zone:".format(ip_address, zone_name)) device = SoCo(ip_address) return device else: print("No cached record for zone") except: return None
def remove_from_group(spkr_ip): my_soco = SoCo(spkr_ip) ans = [] if my_soco is not None: my_soco.unjoin() return ans
def set_volume(ip, vol): my_soco = SoCo(ip) ans = [] if my_soco is not None: my_soco.play_uri(vol) return ans
def get(self, request, format=None): params = request.query_params sound_id = params["sound_id"] speaker_id = params["speaker_id"] if sound_id is None and speaker_id is None: return Response(status=status.HTTP_400_BAD_REQUEST) elif sound_id is None or speaker_id is None: return Response(status=status.HTTP_400_BAD_REQUEST) speaker = Sonos.objects.filter(pk=speaker_id) if not speaker: raise NotFound(detail=_("No Sonos with this id")) sound = Sound.objects.filter(pk=sound_id) if not sound: raise NotFound(detail=_("No sound with this id")) sonos = SoCo(speaker[0].ip_address) uri = 'http://' + get_ip_address() + ':8000/static/data/' + sound[ 0].author.name_text + '/sounds/' + sound[0].file_name_text sonos.play_uri(uri, start=True) sound[0].play_count_integer += 1 sound[0].save() data = {"meta": {"code": status.HTTP_200_OK}} return Response(data, status=status.HTTP_200_OK)
def get_sonos_favorites(request): # pragma: no cover, nuimo_app_config_path = request.registry.settings['nuimo_app_config_path'] mac_address = request.matchdict['mac_address'].replace('-', ':') component_id = request.matchdict['component_id'] with open(nuimo_app_config_path, 'r') as f: config = yaml.load(f) try: nuimo = config['nuimos'][mac_address] except (KeyError, TypeError): return HTTPNotFound("No Nuimo with such ID") components = nuimo['components'] try: component = next(c for c in components if c['id'] == component_id) except StopIteration: raise HTTPNotFound("No Component with such ID") if component['type'] != 'sonos': return HTTPNotFound("No Sonos Component with such ID") sonos_controller = SoCo(component['ip_address']) try: favorites = sonos_controller.get_sonos_favorites() except SoCoException: return HTTPNotFound("Sonos Device not reachable") if favorites['returned'] < 3: return HTTPNotFound("less than Three Favorites on Sonos") return {'favorites': favorites}
def play_local_file(speaker: SoCo, pathname: str, end_on_pause: bool = False) -> bool: if not path.exists(pathname): error_report("File '{}' not found".format(pathname)) return False directory, filename = path.split(pathname) if not is_supported_type(filename): error_report( "Unsupported file type; must be one of: {}".format(SUPPORTED_TYPES) ) return False # Make filename compatible with URL naming url_filename = urllib.parse.quote(filename) server_ip = get_server_ip(speaker) if not server_ip: error_report("Can't determine an IP address for web server") return False logging.info("Using server IP address: {}".format(server_ip)) # Start the webserver (runs in a daemon thread) speaker_ips = [] for zone in speaker.all_zones: speaker_ips.append(zone.ip_address) httpd = http_server(server_ip, directory, url_filename, speaker_ips) if not httpd: error_report("Cannot create HTTP server") return False # This ensures that other running invocations of 'play_file' # receive their stop events, and terminate. logging.info("Stopping speaker '{}'".format(speaker.player_name)) speaker.stop() # Assemble the URI uri = "http://" + server_ip + ":" + str(httpd.server_port) + "/" + url_filename logging.info("Playing file '{}' from directory '{}'".format(filename, directory)) logging.info("Playback URI: {}".format(uri)) logging.info("Send URI to '{}' for playback".format(speaker.player_name)) speaker.play_uri(uri) logging.info("Setting flag to stop playback on CTRL-C") set_speaker_playing_local_file(speaker) logging.info("Waiting 1s for playback to start") time.sleep(1.0) logging.info("Waiting for playback to stop") wait_until_stopped(speaker, uri, end_on_pause) logging.info("Playback stopped ... terminating web server") httpd.shutdown() logging.info("Web server terminated") set_speaker_playing_local_file(None) return True
def stopPlaying(self): for speakerIp in self.sonos.get_speaker_ips(): sonosSpeaker = SoCo(speakerIp) all_info = sonosSpeaker.get_speaker_info() for item in all_info: logging.info("Stopping for speaker %s: %s" % (item, all_info[item])) sonos.stop() LCDScreen.updateStatus("Sonos" , "Music Stopped" )
def GET(self): web.header('Access-Control-Allow-Origin', '*') web.header('Access-Control-Allow-Credentials', 'true') data = web.input(uri="no", player="no") sonos = SoCo('192.168.1.105') sonos.play_uri(data.uri) track = sonos.get_current_track_info() return track['title'] + " - " + data.player
def GET(self, ipadress): web.header('Content-Type', 'application/json') web.header('Access-Control-Allow-Origin', '*') web.header('Access-Control-Allow-Credentials', 'true') sonos = SoCo(ipadress) track = sonos.get_current_track_info() return json.dumps(track)
def volume_down(self): for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol > 0: device.volume(vol-1) return True elif vol == 100: return True
def volume_down(self): for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol > 0: device.volume(vol - 1) return True elif vol == 100: return True
def play(self): self.logger.info('Playing zones...') for ip in self._ZONE_IPS: device = SoCo(ip) self.logger.debug('Playing zone at %s', ip) if not device.play(): self.logger.error('Unable to play zone at %s', ip) return False self.logger.info('All zones playing.') return True
def pause(self): self.logger.info('Pausing zones...') for ip in self._ZONE_IPS: device = SoCo(ip) self.logger.debug('Pausing zone at %s', ip) if not device.pause(): self.logger.error('Unable to pause zone at %s', ip) return False self.logger.info('All zones paused.') return True
def listAll(self): for speakerIp in self.sonos.get_speaker_ips(): logging.info("********* %s ***********" % str(speakerIp)) sonosSpeaker = SoCo(speakerIp) all_info = sonosSpeaker.get_speaker_info() for item in all_info: logging.info(" %s: %s" % (item, all_info[item])) logging.info('co-ordinator = ' + str(sonosSpeaker.get_group_coordinator(all_info['zone_name'], True))) logging.info("****************************" )
def refresh_speaker_info(): sd = SonosDiscovery() possible_matches = sd.get_speaker_ips() speaker_info = {} for ip in possible_matches: s = SoCo(ip) try: speaker_info[ip] = s.get_speaker_info() except Exception, e: speaker_info[ip] = {}
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()
def play_it_ran(): flip_back(index_id) logging.info('random threading') play_room = (str(pod_dict['Rooms']['Living'])) url = 'http://0.0.0.0:5005/preset/all_rooms/' r = requests.get(url) data = requests.get('http://0.0.0.0:5000/random/' + str(pod_id) + "/").json() time.sleep(1) sonos = SoCo(play_room) sonos.play_uri(data['location'])
def action(player: SoCo, action: str): if action == 'play': player.play() elif action == 'stop': player.stop() elif action == 'pause': player.pause() elif action == 'next': player.next() elif action == 'previous': player.previous()
def main(): with closing(MySQLdb.connect( login.DB_HOST, login.DB_USER, login.DB_PASSWORD, login.DB_DATABASE)) as connection: with closing(connection.cursor()) as cursor: cursor.execute('SELECT ip FROM sonos WHERE id="1"') ip = cursor.fetchone()[0] sonos = SoCo(ip) sonos.start_library_update()
def sonos_pause(self): """Afspeellijst, <pause> button, afspelen pauzeren. """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_pause() ## sonos, afspelen pauzeren sonos = SoCo(COORDINATOR) sonos.pause() return h
def sonos_next(self): """Afspeellijst <Next> button, gaat naar volgende nummer in afspeellijst. """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_next() ## sonos = SoCo(COORDINATOR) sonos.next() return h
def sonos_play(self): """Afspeellijst, <play> button, afspelen of doorgaan na een pauze. """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_play() ## sonos, afspelen sonos = SoCo(COORDINATOR) sonos.play() return h
def play_recent(pod_address): url = 'http://localhost:5005/preset/all_rooms' r = requests.get(url) with open('/usr/local/bin/sonos-rooms.json', 'r') as f: d = json.load(f) play_room = (d['Master']) d = feedparser.parse(pod_address) most_recent = d.entries[0].enclosures[0].href sonos = SoCo(play_room) sonos.play_uri(most_recent)
def connect(self, address): try: self.connected_device = SoCo(address) self.connected_device.player_name print_green('Connection active') except ConnectionRefusedError: self.connected_device = None print_red( 'Connection Failed: connection refused to {}'.format(address)) except OSError: self.connected_device = None print_red('Connection Failed: device {} not found'.format(address))
def tune(): station = request.args.get('station') target = request.args.get('target') sonos = SoCo(target) sonos.pause() if station == 'eldoradio': sonos.play_uri('x-rincon-mp3radio://sender.eldoradio.de:8000/high') elif station == 'xfm': sonos.play_uri('x-rincon-mp3radio://live64.917xfm.de') elif station == 'wdr5': sonos.play_uri('x-rincon-mp3radio://wdr-5.akacast.akamaistream.net/7/41/119439/v1/gnl.akacast.akamaistream.net/wdr-5') return 'Ok'
def sonos_previous(self): """Afspeellijst, <Previous> button, gaat naar vorige nummer, in de afspeellijst. """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_previous() ## sonos = SoCo(COORDINATOR) sonos.previous() return h
def playTheme(data, cur, themes, sonosPlayer): if data['hw'] in themes.keys() and getLastAction(data, cur) == 'remove': from soco import SoCo sonos = SoCo(sonosPlayer) if sonos.get_current_transport_info() == 'PLAYING': return ''; sonos.unjoin(); sonos.play_uri(themes[data['hw']]) sonos.volume = 20; if sonos.get_current_transport_info() == 'PLAYING': return ''; sonos.play() syslog.syslog('Playing theme for: ' + data['hw'])
def sonos_play_from_queue(self): """sonos_play_from_queue, speelt queue af """ # pagina laden voor als antwoord terug aan de server h = queuebeheer_temp.sonos_play_from_queue() # queue afspelen als deze niet leeg is sonos = SoCo(COORDINATOR) if len(sonos.get_queue()) > 0: sonos.play_from_queue(0) return h
def connect(self): ips = [] while (len(ips) == 0): print "No Sonos found" sonos_devices = SonosDiscovery() ips = sonos_devices.get_speaker_ips() print "Found {0} device(s)".format(len(ips)) for ip in ips: self._device = SoCo(ip) zone_name = self._device.get_speaker_info()['zone_name'] print "IP of {0} is {1}".format(zone_name, ip)
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 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")
class Sonos: def __init__(self, ip): self.sonos = SoCo(ip) self.sonos.volume = 60 def playJason(self): self.sonos.play_uri("x-sonos-spotify:spotify%3atrack%3a6g6A7qNhTfUgOSH7ROOxTD?sid=12&flags=32") time.sleep(1) self.sonos.pause() def randomKatyPerrySong(self): darkHorse = 'x-sonos-spotify:spotify%3atrack%3a5jrdCoLpJSvHHorevXBATy?sid=12&flags=32' firework = 'x-sonos-spotify:spotify%3atrack%3a4lCv7b86sLynZbXhfScfm2?sid=12&flags=32' roar = 'x-sonos-spotify:spotify%3atrack%3a3XSczvk4MRteOw4Yx3lqMU?sid=12&flags=32' birthday = 'x-sonos-spotify:spotify%3atrack%3a2xLOMHjkOK8nzxJ4r6yOKR?sid=12&flags=32' californiaGurls = 'x-sonos-spotify:spotify%3atrack%3a6tS3XVuOyu10897O3ae7bi?sid=12&flags=32' teenageDream = 'x-sonos-spotify:spotify%3atrack%3a55qBw1900pZKfXJ6Q9A2Lc?sid=12&flags=32' lastFridayNight = 'x-sonos-spotify:spotify%3atrack%3a455AfCsOhhLPRc68sE01D8?sid=12&flags=32' peacock = 'x-sonos-spotify:spotify%3atrack%3a3y3Hucw52QpjtHUeOKTkaO?sid=12&flags=32' et = 'x-sonos-spotify:spotify%3atrack%3a4kkeuVl6gF3RMqE4Nn5W3E?sid=12&flags=32' songs = [darkHorse, firework, roar, birthday, californiaGurls, teenageDream, lastFridayNight, peacock, et] chosen_song = random.choice(songs) return chosen_song def playKatyPerry(self): self.playJason() self.sonos.play_uri(self.randomKatyPerrySong()) # set Katy Perry duration here (in seconds) time.sleep(10) self.sonos.pause()
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 __init__(self): self.logger = logging.getLogger(__name__) self.logger.setLevel(logging.DEBUG) fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' fmt = logging.Formatter(fmt) # Configuring logging to file # Currently logs everything DEBUG and above logfile = logging.FileHandler('clock.log') logfile.setLevel(logging.DEBUG) logfile.setFormatter(fmt) self.logger.addHandler(logfile) # Configuring logging to stdout # Currently logs everything INFO and above:w stderr_handle = logging.StreamHandler() stderr_handle.setLevel(logging.INFO) stderr_handle.setFormatter(fmt) self.logger.addHandler(stderr_handle) self.logger.info('Starting log...') # Time variables self._then = '' # Player variables self._ZONE_IPS = [] self.logger.info('Searching for zones...') disc = SonosDiscovery() self.household = {} self.logger.info('Building household tree...') for ip in disc.get_speaker_ips(): device = SoCo(ip) try: zone = device.get_speaker_info()['zone_name'] if zone != None: if self.household.has_key(zone): self.household[zone].append(ip) else: self.household[zone] = [] self.household[zone].append(ip) except ValueError: msg = 'Zone with no name at '+ip+', possibly a bridge' self.logger.error(msg) continue
def __init__(self): self.logger = logging.getLogger(__name__) self.logger.setLevel(logging.DEBUG) fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' fmt = logging.Formatter(fmt) # Configuring logging to file # Currently logs everything DEBUG and above logfile = logging.FileHandler('clock.log') logfile.setLevel(logging.DEBUG) logfile.setFormatter(fmt) self.logger.addHandler(logfile) # Configuring logging to stdout # Currently logs everything INFO and above:w stderr_handle = logging.StreamHandler() stderr_handle.setLevel(logging.INFO) stderr_handle.setFormatter(fmt) self.logger.addHandler(stderr_handle) self.logger.info('Starting log...') # Time variables self._then = '' # Player variables self._ZONE_IPS = [] self.logger.info('Searching for zones...') disc = SonosDiscovery() self.household = {} self.logger.info('Building household tree...') for ip in disc.get_speaker_ips(): device = SoCo(ip) try: zone = device.get_speaker_info()['zone_name'] if zone != None: if self.household.has_key(zone): self.household[zone].append(ip) else: self.household[zone] = [] self.household[zone].append(ip) except ValueError: msg = 'Zone with no name at ' + ip + ', possibly a bridge' self.logger.error(msg) continue
def get_zone(zone_name): import re devices = discover() cache_name = "{}_ip.txt".format(zone_name) if devices: for device in devices: if device.player_name == zone_name: # Save the well known IP of the device for future cache # When discover() fails need to fallback to this solution #try: f = open(cache_name, "w+") f.write(device.ip_address) f.close() return device if not devices or len(devices) == 0: print("WARNING: No devices found through discover.") # Device not found, try be known IP try: if os.path.isfile(cache_name) and os.access(cache_name, os.R_OK): f = open(cache_name, "r") line = f.readline() ip_address = re.search(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', line).group() f.close() print("Using cached IP:{} for zone:{}".format( ip_address, zone_name)) device = SoCo(ip_address) return device else: print("No cached record for zone") except: print("Exception reading cached record") return None
def main(): sd = SonosDiscovery() speakers = sd.get_speaker_ips() if not speakers: print 'no speakers found, exiting.' return soco = SoCo(speakers[0]) # get a plugin by name (eg from a config file) myplugin = SoCoPlugin.from_name('soco.plugins.example.ExamplePlugin', soco, 'some user') # do something with your plugin print 'Testing', myplugin.name myplugin.music_plugin_play() time.sleep(5) # create a plugin by normal instantiation from soco.plugins.example import ExamplePlugin # create a new plugin, pass the soco instance to it myplugin = ExamplePlugin(soco, 'a user') print 'Testing', myplugin.name # do something with your plugin myplugin.music_plugin_stop()
def GET(self): web.header('Content-Type', 'application/json') web.header('Access-Control-Allow-Origin', '*') web.header('Access-Control-Allow-Credentials', 'true') data = web.input(player="blank") sonos = SoCo(data.player) track = sonos.get_current_track_info() return json.dumps(track)
def main(): speakers = [speaker.ip_address for speaker in SoCo.discover()] if not speakers: print 'no speakers found, exiting.' return soco = SoCo(speakers[0]) # get a plugin by name (eg from a config file) myplugin = SoCoPlugin.from_name('soco.plugins.example.ExamplePlugin', soco, 'some user') # do something with your plugin print 'Testing', myplugin.name myplugin.music_plugin_play() time.sleep(5) # create a plugin by normal instantiation from soco.plugins.example import ExamplePlugin # create a new plugin, pass the soco instance to it myplugin = ExamplePlugin(soco, 'a user') print 'Testing', myplugin.name # do something with your plugin myplugin.music_plugin_stop()
def decir2(texto): track = sonos.get_current_track_info() playlistPos = int(track['playlist_position'])-1 trackPos = track['position'] trackURI = track['uri'] # This information allows us to resume services like Pandora mediaInfo = sonos.avTransport.GetMediaInfo([('InstanceID', 0)]) mediaURI = mediaInfo['CurrentURI'] mediaMeta = mediaInfo['CurrentURIMetaData'] ok, file_name = text2mp3(texto, PATH, LANGUAGE, False) if ok: zp = SoCo(ip_sonos) print('x-file-cifs:%s' % '//homeserver/sonidos/speech.mp3') zp.play_uri('x-file-cifs:%s' % '//homeserver/sonidos/speech.mp3')
def volume_down(self): self.logger.info('Lowering volume...') for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol > 0: self.logger.debug('Setting volume to %d', vol-1) if not device.volume(vol-1): self.logger.error('Could not set volume at %s.', ip) return False else: self.logger.error('Lowered volume.') return True elif vol == 100: self.logger.info('Volume at min, could not lower.') return True
def volume_up(self): self.logger.info('Raising volume...') for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol < 100: self.logger.debug('Setting volume to %d', vol+1) if not device.volume(vol+1): self.logger.error('Could not set volume at %s.', ip) return False else: self.logger.info('Raised volume.') return True elif vol == 100: self.logger.info('Volume at max, could not raise.') return True
def getSonos(): settings = selfAddon.getSetting player_ip = settings('SONOS_PLAYER_IP') sonos = SoCo("%s" % player_ip) xbmc.log("SONOS: created soco with ip: %s" % player_ip) return sonos
def volume_up(self): self.logger.info('Raising volume...') for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol < 100: self.logger.debug('Setting volume to %d', vol + 1) if not device.volume(vol + 1): self.logger.error('Could not set volume at %s.', ip) return False else: self.logger.info('Raised volume.') return True elif vol == 100: self.logger.info('Volume at max, could not raise.') return True
def volume_down(self): self.logger.info('Lowering volume...') for ip in self._ZONE_IPS: device = SoCo(ip) vol = int(device.volume()) if vol > 0: self.logger.debug('Setting volume to %d', vol - 1) if not device.volume(vol - 1): self.logger.error('Could not set volume at %s.', ip) return False else: self.logger.error('Lowered volume.') return True elif vol == 100: self.logger.info('Volume at min, could not lower.') return True
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 playStation(self, stationNameLike, onSpeakerLike): LCDScreen.updateStatus("Pandora", "Loading music") stationId = self.rpandora.getIdForStation(stationNameLike) stationName = self.rpandora.getNameForStation(stationNameLike) LCDScreen.updateStatus("Pl: %s" % stationName, "On %s" % onSpeakerLike ) for speakerIp in self.sonos.get_speaker_ips(): try: sonosSpeaker = SoCo(str(speakerIp)) all_info = sonosSpeaker.get_speaker_info() if onSpeakerLike in all_info['zone_name'] : logging.info("Playing on speaker %s" % str(speakerIp)) sonosSpeaker.play_uri("pndrradio:%s" % str(stationId), '') LCDScreen.updateStatus("Pl: %s" % stationName, "On %s" % all_info['zone_name'] ) else: logging.info('Skipping player "%s"' % all_info['zone_name']) except: logging.error('Failed calling %s' % speakerIp)
def main(): ''' Test stub to call the say routine. Command line provides the words to say in inverted commas If omitted then uses a default text ''' #use text argument from command line if present - else use default if len(sys.argv) < 2: txt = DEFUALT_TEXT else: txt = sys.argv[1] print ('Testing using %s character string "%s"' % (len(txt), txt) ) ok, file_name = text2mp3(txt, PATH, LANGUAGE, ALERT) #if TTS worked OK, use file name returned to play MP3 on Sonos if ok: zp = SoCo(IP) zp.play_uri('x-file-cifs:%s' % file_name) print 'Listen to your Sonos - check volume turned up!'