def start_casting(call):
"""service called."""
from pychromecast.controllers.spotify import SpotifyController
import spotipy
uri = call.data.get(CONF_SPOTIFY_URI)
if call.data.get(CONF_DEVICE_NAME) is None:
device_name = hass.states.get(
call.data.get(CONF_ENTITY_ID)).attributes.get('friendly_name')
else:
device_name = call.data.get(CONF_DEVICE_NAME)
_LOGGER.debug('Starting spotify on %s', device_name)
# Find chromecast device
cast = get_chromcast_device(device_name)
cast.wait()
account = call.data.get(CONF_SPOTIFY_ACCOUNT)
user = username
pwd = password
if account is not None:
_LOGGER.debug('setting up with different account than default %s',
account)
user = accounts.get(account).get(CONF_USERNAME)
pwd = accounts.get(account).get(CONF_PASSWORD)
# login as real browser to get powerful token
access_token, expires = get_spotify_token(username=user, password=pwd)
client = spotipy.Spotify(auth=access_token)
# launch the app on chromecast
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
raise HomeAssistantError(
'Failed to launch spotify controller due to timeout')
if not sp.is_launched and sp.credential_error:
raise HomeAssistantError(
'Failed to launch spotify controller due to credentials error')
spotify_device_id = None
devices_available = client.devices()
for device in devices_available['devices']:
if device['id'] == sp.device:
spotify_device_id = device['id']
break
if not spotify_device_id:
_LOGGER.error('No device with id "{}" known by Spotify'.format(
sp.device))
_LOGGER.error('Known devices: {}'.format(
devices_available['devices']))
return
play(client, spotify_device_id, uri)
def startSpotifyController(self, access_token, expires):
sp = SpotifyController(access_token, expires)
self.castDevice.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
raise HomeAssistantError(
"Failed to launch spotify controller due to timeout")
if not sp.is_launched and sp.credential_error:
raise HomeAssistantError(
"Failed to launch spotify controller due to credentials error")
self.spotifyController = sp
def play():
try:
output_chromecast_ip = sys.argv[1]
uri_to_play = sys.argv[2]
shuffle = sys.argv[3]
if type(shuffle != bool):
shuffle = string_to_bool(shuffle)
redis_connection = try_to_connect_to_redis()
spotify_token_info = RefreshSpotifyTokenIfNecessary(redis_connection)
cast = Chromecast(output_chromecast_ip)
cast.wait()
client = spotipy.Spotify(auth=spotify_token_info["access_token"])
sp = SpotifyController(spotify_token_info["access_token"],
spotify_token_info["seconds_left"])
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print(
'Failed to launch spotify controller due to credential error')
sys.exit(1)
devices_available = client.devices()
spotify_device_id = None
for device in devices_available['devices']:
if device['id'] == sp.device:
spotify_device_id = device['id']
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print('Known devices: {}'.format(devices_available['devices']))
sys.exit(1)
# # Start playback
if uri_to_play.find('track') > 0:
client.start_playback(device_id=spotify_device_id,
uris=[uri_to_play])
else:
client.start_playback(device_id=spotify_device_id,
context_uri=[uri_to_play])
time.sleep(2)
client.shuffle(shuffle)
return True
except Exception as e:
print("Couldn't Load URI and Play Spotify")
print(e)
return False
def launch_spotify_app():
global shared_options
global shared_chromecast
global shared_spotify_client
global shared_spotify_device_id
try:
if shared_chromecast == False:
init_chromecast(shared_options)
shared_spotify_client = False
shared_spotify_client = spotipy.Spotify(
auth=shared_options['spotify_token_info']["access_token"])
sp = SpotifyController(
shared_options['spotify_token_info']["access_token"],
shared_options['spotify_token_info']["seconds_left"])
shared_chromecast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
return False
if not sp.is_launched and sp.credential_error:
print(
'Failed to launch spotify controller due to credential error')
return False
devices_available = shared_spotify_client.devices()
#shared_spotify_device_id = False
print("Available Devices ==")
print(devices_available['devices'])
for device in devices_available['devices']:
if device['is_active'] == True:
# if device[ 'name' ] == "Attic TV":
# shared_spotify_device_id = device['id']
# break
if device['type'] == "CastVideo":
shared_spotify_device_id = device['id']
break
if device['id'] == sp.device:
shared_spotify_device_id = device['id']
break
if not shared_spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print('Known devices: {}'.format(devices_available['devices']))
return False
return True
except Exception as e:
print(e)
shared_spotify_client = False
shared_spotify_device_id = False
return False
def start_casting(call):
"""service called."""
from pychromecast.controllers.spotify import SpotifyController
import spotipy
uri = call.data.get(CONF_SPOTIFY_URI)
device_name = call.data.get(CONF_DEVICE_NAME)
_LOGGER.info('Starting spotify on %s', device_name)
# Find chromecast device
cast = get_chromcase_device(device_name)
cast.wait()
account = call.data.get(CONF_SPOTIFY_ACCOUNT)
user = username
pwd = password
if account is not None:
_LOGGER.info('setting up with different account than default %s',
account)
user = accounts.get(account).get(CONF_USERNAME)
pwd = accounts.get(account).get(CONF_PASSWORD)
# login as real browser to get powerful token
access_token, expires = get_spotify_token(username=username,
password=password)
client = spotipy.Spotify(auth=access_token)
# launch the app on chromecast
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
spotify_device_id = None
devices_available = client.devices()
for device in devices_available['devices']:
if device['name'] == device_name:
spotify_device_id = device['id']
break
play(client, spotify_device_id, uri)
def startSpotifyController(self, access_token, expires):
from pychromecast.controllers.spotify import SpotifyController
# get the volume so we can remove the bloink
# volume = self.castDevice.status.volume_level
# self.castDevice.set_volume(0)
sp = SpotifyController(access_token, expires)
self.castDevice.register_handler(sp)
sp.launch_app()
# reset the volume
# self.castDevice.set_volume(volume)
if not sp.is_launched and not sp.credential_error:
raise HomeAssistantError('Failed to launch spotify controller due to timeout')
if not sp.is_launched and sp.credential_error:
raise HomeAssistantError('Failed to launch spotify controller due to credentials error')
self.spotifyController = sp
def play_music(song_uri):
devices = pychromecast.get_chromecasts()
speaker = next(cc for cc in devices
if cc.device.friendly_name == CAST_NAME)
speaker.wait()
data = st.start_session("little_wang", "Jumbobean123")
access_token = data[0]
expires = data[1] - int(time.time())
client = spotipy.Spotify(auth=access_token)
sp = SpotifyController(access_token, expires)
speaker.register_handler(sp)
sp.launch_app()
devices_available = client.devices()
for device in devices_available['devices']:
if device['name'] == CAST_NAME:
device_id = device['id']
break
speaker.set_volume(0.5)
client.start_playback(device_id=device_id, uris=[song_uri])
def play_currated_uris(spotify_token_info, chromecast_output_ip, uris):
try:
cast = Chromecast(chromecast_output_ip)
cast.wait()
cast.media_controller.stop()
#client = spotipy.Spotify( auth=spotify_token_info[ "access_token" ] )
client = spotipy.Spotify(auth=spotify_token_info["access_token"])
sp = SpotifyController(spotify_token_info["access_token"],
spotify_token_info["seconds_left"])
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
return False
if not sp.is_launched and sp.credential_error:
print(
'Failed to launch spotify controller due to credential error')
return False
devices_available = client.devices()
spotify_device_id = None
for device in devices_available['devices']:
if device['id'] == sp.device:
spotify_device_id = device['id']
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print('Known devices: {}'.format(devices_available['devices']))
return False
client.start_playback(device_id=spotify_device_id, uris=uris)
time.sleep(2)
client.volume(99)
time.sleep(2)
client.volume(100)
client.shuffle(False)
return True
except Exception as e:
print("Couldn't Load Spotify Chromecast App")
print(e)
return False
def _getSpotifyChromecastController():
try:
spotifyUserUsername = os.environ['SPOTIFY_USER_USERNAME']
spotifyUserPassword = os.environ['SPOTIFY_USER_PASSWORD']
except KeyError:
raise SpotifyPlaybackError(
'Missing Spotify user credentials in env vars '
'`SPOTIFY_USER_USERNAME` and/or `SPOTIFY_USER_PASSWORD`')
(spotifyControllerAccessToken,
spotifyControllerExpiresAt) = spotify_token.start_session(
spotifyUserUsername, spotifyUserPassword)
spotifyControllerExpiresIn = spotifyControllerExpiresAt - int(time())
return SpotifyController(spotifyControllerAccessToken,
spotifyControllerExpiresIn)
def initialize(self):
self.sp_key = sp_key
self.sp_dc = sp_dc
token, expires = spotify_token.start_session(sp_dc, sp_key)
self.spotify_controller = SpotifyController(token, expires)
username = self.settings.get('username')
password = self.settings.get('password')
self.log.info("Settings:" + str(self.settings))
self.log.info("Username:"******"Password:"******"Init device")
self.log.info("Init spotify cast skill")
thread = threading.Thread(target=self.update_chromecasts)
thread.start()
def play_spotify(user,
password,
uri=["spotify:track:3Zwu2K0Qa5sT6teCCHPShP"],
show_debug=False,
cast="Sadie's TV"):
if show_debug:
logging.basicConfig(level=logging.DEBUG)
# Uncomment to enable http.client debug log
#http_client.HTTPConnection.debuglevel = 1
# Store the ip in a txt file
# Open File
cast_ip = None
with open('cast.txt', 'r+') as f:
print("This is the file pointer", f)
if len(f.read(1)) == 0:
cast = discover_casts(cast)
else:
f.seek(0)
cast_ip = [line for line in f][0]
cast = get_cast(cast_ip, cast)
if (cast.host != cast_ip):
f.write(cast.host)
# Wait for connection to the chromecast
cast.wait()
spotify_device_id = None
# Create a spotify token
data = st.start_session(user, password)
access_token = data[0]
expires = data[1] - int(time.time())
# Create a spotify client
client = spotipy.Spotify(auth=access_token)
if show_debug:
spotipy.trace = True
spotipy.trace_out = True
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print('Failed to launch spotify controller due to credential error')
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available['devices']:
if device['id'] == sp.device:
spotify_device_id = device['id']
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print('Known devices: {}'.format(devices_available['devices']))
sys.exit(1)
# Start playback
if uri[0].find('track') > 0:
client.start_playback(device_id=spotify_device_id, uris=uri)
else:
client.start_playback(device_id=spotify_device_id, context_uri=uri[0])
def launch_spotify(target, user, password, uri):
chromecasts = pychromecast.get_listed_chromecasts(friendly_names=target)
cast = None
for _cast in chromecasts:
if _cast.name == target:
cast = _cast
break
if not cast:
print('No chromecast with name "{}" discovered'.format(target))
print("Discovered casts: {}".format(chromecasts))
sys.exit(1)
print("cast {}".format(cast))
class ConnListener:
def __init__(self, mz):
self._mz = mz
def new_connection_status(self, connection_status):
"""Handle reception of a new ConnectionStatus."""
if connection_status.status == "CONNECTED":
self._mz.update_members()
class MzListener:
def __init__(self):
self.got_members = False
def multizone_member_added(self, uuid):
pass
def multizone_member_removed(self, uuid):
pass
def multizone_status_received(self):
self.got_members = True
# Wait for connection to the chromecast
cast.wait()
spotify_device_id = None
# Create a spotify token
data = st.start_session(user, password)
access_token = data[0]
expires = data[1] - int(time.time())
#Create spotify client
client = spotipy.Spotify(auth=access_token)
# Launch the spotify app on cast device
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print("Failed to launch spotify controller due to timeout")
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print("Failed to launch spotify controller due to credential error")
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available["devices"]:
if device["id"] == sp.device:
spotify_device_id = device["id"]
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print("Known devices: {}".format(devices_available["devices"]))
sys.exit(1)
# Start playback
client.start_playback(device_id=spotify_device_id, context_uri=uri)
logging.basicConfig(level=logging.DEBUG)
chromecasts = pychromecast.get_chromecasts()
cast = None
for _cast in chromecasts:
if _cast.name == CAST_NAME:
cast = _cast
break
if cast:
cast.wait()
device_id = None
data = st.start_session("SPOTIFY_USERNAME", "SPOTIFY_PASSWORD")
access_token = data[0]
client = spotipy.Spotify(auth=access_token)
sp = SpotifyController(access_token)
cast.register_handler(sp)
sp.launch_app()
devices_available = client.devices()
for device in devices_available['devices']:
if device['name'] == CAST_NAME:
device_id = device['id']
break
client.start_playback(device_id=device_id,
uris=["spotify:track:3Zwu2K0Qa5sT6teCCHPShP"])
def play(args):
cast.wait()
spotify_device_id = None
# Create a spotify token
data = st.start_session(
'AQCNDwe7-v4N1F0SLn_HbosHFppfrYvUW-RON3cq-l17dFWIxNEItMSC_Ydm3kN1sBnz8lIucTzx9XC0B-fYAdTi_tODOmqf0mR2LNVJ9Q',
'03439c8c-2dc1-45c4-85e1-55726b431177')
access_token = data[0]
expires = data[1] - int(time.time())
# Create a spotify client
client = spotipy.Spotify(auth=access_token)
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print("Failed to launch spotify controller due to timeout")
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print("Failed to launch spotify controller due to credential error")
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available["devices"]:
if device["id"] == sp.device:
spotify_device_id = device["id"]
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print("Known devices: {}".format(devices_available["devices"]))
sys.exit(1)
def getTracks(uri):
split = uri.split(":")
def doAlbum(_id):
tracks = client.album_tracks(_id)
return tracks['total'], uri
if split[1] == "playlist":
playlist = client.playlist(split[2])
num_tracks = playlist['tracks']['total']
return num_tracks, uri
elif split[1] == "artist":
# Turn it into one of their albums
raw = client.artist_albums(split[2])
albums = raw['items']
uri = random.choice(albums)['uri']
return doAlbum(uri.split(":")[2])
elif split[1] == "album":
return doAlbum(split[2])
def getName(str):
ttype = str.split(":")[1]
item = client.track(str) if ttype == 'track' \
else client.album(str) if ttype == 'album' \
else client.artist(str) if ttype == 'artist' \
else client.playlist(str)
return item['name']
# Start playback
def playMusic():
if args.uri[0] == 'unset':
dat = client.user_playlists("12144944831")['items']
# Get the playlists for my account
dd = [o['id'] for o in dat]
dd2 = [o['name'] for o in dat]
choice = random.choice(dd)
uuri = "spotify:playlist:{}".format(choice)
num_tracks, uri = getTracks(uuri)
print("♫ Playing " + dd2[dd.index(choice)] + " ♫")
client.start_playback(
device_id=spotify_device_id,
context_uri=uuri,
offset={"position": random.randint(0, num_tracks - 1)})
cast.wait()
volume.setVolume(volume.MUSIC_VOLUME, "Spotify")
client.shuffle(True, device_id=spotify_device_id)
else:
name = getName(args.uri[0])
print("♫ Playing: " + name + " ♫")
if args.uri[0].find("track") > 0:
client.start_playback(device_id=spotify_device_id,
uris=args.uri)
else:
num_tracks, uri = getTracks(args.uri[0])
client.start_playback(
device_id=spotify_device_id,
context_uri=uri,
offset={"position": random.randint(0, num_tracks - 1)})
volume.setVolume(volume.MUSIC_VOLUME, "Spotify")
client.shuffle(True, device_id=spotify_device_id)
playMusic()
def run_spotify():
"""
Example on how to use the Spotify Controller.
NOTE: You need to install the spotipy and spotify-token dependencies.
This can be done by running the following:
pip install spotify-token
pip install git+https://github.com/plamere/spotipy.git
"""
import argparse
import logging
import time
import sys
import pychromecast
from pychromecast.controllers.spotify import SpotifyController
import spotify_token as st
import spotipy
CAST_NAME = "My Chromecast"
parser = argparse.ArgumentParser(
description="Example on how to use the Spotify Controller.")
parser.add_argument("--show-debug",
help="Enable debug log",
action="store_true")
parser.add_argument("--cast",
help='Name of cast device (default: "%(default)s")',
default=CAST_NAME)
parser.add_argument("--user", help="Spotify username", required=True)
parser.add_argument("--password", help="Spotify password", required=True)
parser.add_argument(
"--uri",
help='Spotify uri(s) (default: "%(default)s")',
default=["spotify:track:3Zwu2K0Qa5sT6teCCHPShP"],
nargs="+",
)
args = parser.parse_args()
if args.show_debug:
logging.basicConfig(level=logging.DEBUG)
# Uncomment to enable http.client debug log
# http_client.HTTPConnection.debuglevel = 1
chromecasts = pychromecast.get_listed_chromecasts(
friendly_names=[args.cast])
cast = None
for _cast in chromecasts:
if _cast.name == args.cast:
cast = _cast
break
if not cast:
print('No chromecast with name "{}" discovered'.format(args.cast))
print("Discovered casts: {}".format(chromecasts))
sys.exit(1)
print("cast {}".format(cast))
class ConnListener:
def __init__(self, mz):
self._mz = mz
def new_connection_status(self, connection_status):
"""Handle reception of a new ConnectionStatus."""
if connection_status.status == "CONNECTED":
self._mz.update_members()
class MzListener:
def __init__(self):
self.got_members = False
def multizone_member_added(self, uuid):
pass
def multizone_member_removed(self, uuid):
pass
def multizone_status_received(self):
self.got_members = True
# Wait for connection to the chromecast
cast.wait()
spotify_device_id = None
# Create a spotify token
data = st.start_session(args.user, args.password)
access_token = data[0]
expires = data[1] - int(time.time())
# Create a spotify client
client = spotipy.Spotify(auth=access_token)
if args.show_debug:
spotipy.trace = True
spotipy.trace_out = True
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print("Failed to launch spotify controller due to timeout")
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print("Failed to launch spotify controller due to credential error")
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available["devices"]:
if device["id"] == sp.device:
spotify_device_id = device["id"]
break
if not spotify_device_id:
print('No device with id "{}" known by Spotify'.format(sp.device))
print("Known devices: {}".format(devices_available["devices"]))
sys.exit(1)
# Start playback
if args.uri[0].find("track") > 0:
client.start_playback(device_id=spotify_device_id, uris=args.uri)
else:
client.start_playback(device_id=spotify_device_id,
context_uri=args.uri[0])
spotify_device_id = None
# Create a spotify token
data = st.start_session(args.user, args.password)
access_token = data[0]
expires = data[1] - int(time.time())
# Create a spotify client
client = spotipy.Spotify(auth=access_token)
if args.show_debug:
spotipy.trace = True
spotipy.trace_out = True
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print('Failed to launch spotify controller due to credential error')
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available['devices']:
RefreshSpotifyTokenIfNecessary()
cast = Chromecast( OurPersonalDB.self[ "chromecast_ip" ] )
print('cast {}'.format(cast))
cast.wait()
spotify_device_id = None
# Create a spotify client
client = spotipy.Spotify( auth=OurSpotifyTokenDB.self[ "access_token" ] )
spotipy.trace = True
spotipy.trace_out = True
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController( OurSpotifyTokenDB.self[ "access_token" ] , OurSpotifyTokenDB.self[ "seconds_left" ] )
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print('Failed to launch spotify controller due to credential error')
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available['devices']:
def start_casting(call):
"""service called."""
from pychromecast.controllers.spotify import SpotifyController
import spotipy
transfer_playback = False
uri = call.data.get(CONF_SPOTIFY_URI)
random_song = call.data.get(CONF_RANDOM, False)
repeat = call.data.get(CONF_REPEAT)
# Get device name from tiehr device_name or entity_id
device_name = None
if call.data.get(CONF_DEVICE_NAME) is None:
entity_id = call.data.get(CONF_ENTITY_ID)
if entity_id is None:
raise HomeAssistantError(
'Either entity_id or device_name must be specified')
entity_states = hass.states.get(entity_id)
if entity_states is None:
_LOGGER.error('Could not find entity_id: %s', entity_id)
else:
device_name = entity_states.attributes.get('friendly_name')
else:
device_name = call.data.get(CONF_DEVICE_NAME)
if device_name is None or device_name.strip() == '':
raise HomeAssistantError('device_name is empty')
# Find chromecast device
cast = get_chromecast_device(device_name)
_LOGGER.debug('Found cast device: %s', cast)
cast.wait()
account = call.data.get(CONF_SPOTIFY_ACCOUNT)
user = username
pwd = password
if account is not None:
_LOGGER.debug('setting up with different account than default %s',
account)
user = accounts.get(account).get(CONF_USERNAME)
pwd = accounts.get(account).get(CONF_PASSWORD)
# login as real browser to get powerful token
access_token, expires = get_spotify_token(username=user, password=pwd)
# get the spotify web api client
client = spotipy.Spotify(auth=access_token)
# Check if something is playing
if uri is None or uri.strip() == '' or call.data.get(
CONF_TRANSFER_PLAYBACK):
current_playback = client.current_playback()
if current_playback is not None:
_LOGGER.debug('current_playback from spotipy: %s',
current_playback)
transfer_playback = True
# launch the app on chromecast
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
raise HomeAssistantError(
'Failed to launch spotify controller due to timeout')
if not sp.is_launched and sp.credential_error:
raise HomeAssistantError(
'Failed to launch spotify controller due to credentials error')
spotify_device_id = None
devices_available = client.devices()
for device in devices_available['devices']:
if device['id'] == sp.device:
spotify_device_id = device['id']
break
if not spotify_device_id:
_LOGGER.error('No device with id "{}" known by Spotify'.format(
sp.device))
_LOGGER.error('Known devices: {}'.format(
devices_available['devices']))
return
if transfer_playback == True:
transfer_pb(client, spotify_device_id)
else:
play(client, spotify_device_id, uri, random_song, repeat)
from pychromecast import Chromecast
from pychromecast.controllers.spotify import SpotifyController
import spotify_token
username = input("Spotify username: "******"Spotify password: "******"Honeycast url: ") or "localhost"
session = spotify_token.start_session(username, password)
token = session[0]
cast = Chromecast(cast_address)
controller = SpotifyController(token)
cast.register_handler(controller)
controller.launch_app()
spotify_device_id = None
# Create a spotify token
data = st.start_session(args.user, args.password)
access_token = data[0]
expires = data[1] - int(time.time())
# Create a spotify client
client = spotipy.Spotify(auth=access_token)
if args.show_debug:
spotipy.trace = True
spotipy.trace_out = True
# Launch the spotify app on the cast we want to cast to
sp = SpotifyController(access_token, expires)
cast.register_handler(sp)
sp.launch_app()
if not sp.is_launched and not sp.credential_error:
print('Failed to launch spotify controller due to timeout')
sys.exit(1)
if not sp.is_launched and sp.credential_error:
print('Failed to launch spotify controller due to credential error')
sys.exit(1)
# Query spotify for active devices
devices_available = client.devices()
# Match active spotify devices with the spotify controller's device id
for device in devices_available['devices']:
def RestartSpotify(q,uri,TrackId = None,ContextUri = None,seektime=0,ContextType = None,Offset = None):
global _plugin
try:
#Get the latest played music from Spotify if not given as parameters
TrackInfo = _plugin.SpotifyClient.current_user_recently_played(limit=1)
if TrackId == None and ContextUri == None:
if TrackInfo['items'][0]['context'] != None:
ContextUri = TrackInfo['items'][0]['context']['uri']
ContextType = TrackInfo['items'][0]['context']['type']
Offset = {"uri": TrackInfo['items'][0]['track']['uri']}
else:
TrackId = [TrackInfo['items'][0]['track']['uri']]
elif ContextUri != None:
Offset = {"uri": TrackId}
TrackId = None
elif TrackId != None and ContextUri == None:
TrackId = [TrackId]
#Connect to chromecast
ip = uri.split(":")[0]
port = int(uri.split(":")[1])
cc = pychromecast.Chromecast(ip,port)
cc.start()
cc.wait()
sp = SpotifyController(_plugin.SpotifyAccessToken, _plugin.SpotifyExpiryTime)
cc.register_handler(sp)
#Launch spotify app on chromecast and find device id
device_id = None
sp.launch_app()
if _plugin.Debug == True:
q.put("Spotify started.")
devices_available = _plugin.SpotifyClient.devices()
for device in devices_available['devices']:
if device['name'] == cc.name:
device_id = device['id']
break
if ContextUri != None:
if _plugin.Debug == True:
q.put("Spotify user id is " + str(_plugin.SpotifyUserId) + " contexturi is " + str(ContextUri) + " Offset is " + str(Offset))
if ContextType == 'artist':
Name = _plugin.SpotifyClient.artist(ContextUri)["name"]
Offset = None
elif ContextType == "album":
Name = _plugin.SpotifyClient.album("spotify:album:3KHPqtzQKRPKup29xEQWtg")["name"]
else:
Name = _plugin.SpotifyClient.user_playlist(_plugin.SpotifyUserId,ContextUri,"name")["name"]
if Offset != None:
q.put("Restarted playback of " + str(ContextType) + " with the name '" + str(Name) + "' and track '" + TrackInfo['items'][0]['track']['name'] + "'" )
elif ContextUri != None:
q.put("Restarted playback of " + str(ContextType) + " with the name '"+ str(Name) + "'")
else:
q.put('Restarted playback of track "' + TrackInfo['items'][0]['track']['name'] +'"' )
if _plugin.Debug == True:
q.put("Spotify arguments are: uris "+str(TrackId) + " context uri " + str(ContextUri) + " offset " + str(Offset))
try:
_plugin.SpotifyClient.start_playback(device_id=device_id, uris=TrackId, context_uri=ContextUri, offset=Offset)
except:
try:
_plugin.SpotifyClient.start_playback(device_id=device_id, uris=TrackId, context_uri=ContextUri)
except Exception as e:
q.put('Error on line {}'.format(sys.exc_info()[-1].tb_lineno)+" Error is: " +str(e))
if seektime != 0:
_plugin.SpotifyClient.seek_track(seektime)
q.put("Searched in track to previous position")
cc.disconnect()
if _plugin.Debug == True:
q.put("Restarting Spotify is done")
except Exception as e:
if "Could not connect to" in str(e):
q.put("Could not start Spotify as the chrmecast is not connected.")
else:
q.put('Error on line {}'.format(sys.exc_info()[-1].tb_lineno)+" Error is: " +str(e))