def my_library_playlists():
# Auto playlists - "Thumbs up" and "Last added"
thumbs_up = xbmcgui.ListItem(utils.translate(30027))
thumbs_up.setArt({
'thumb': thumbs.IMG_THUMB_UP,
'poster': thumbs.IMG_THUMB_UP
})
last_added = xbmcgui.ListItem(utils.translate(30026))
last_added.setArt({'thumb': thumbs.IMG_CLOCK, 'poster': thumbs.IMG_CLOCK})
items = [
(utils.build_url(
url=URL,
paths=['browse', 'my-library', 'playlist', 'thumbsup'],
r_path=True,
r_query=True), thumbs_up, True),
(utils.build_url(
url=URL,
paths=['browse', 'my-library', 'playlist', 'lastadded'],
r_path=True,
r_query=True), last_added, True),
]
# User playlists
items += listing.build_playlist_listitems(GMUSIC.get_user_playlists())
listing.list_playlists(items)
def artist(artist_id):
top_songs = xbmcgui.ListItem(utils.translate(30066))
top_songs.setArt({'thumb': thumbs.IMG_STAR, 'poster': thumbs.IMG_STAR})
related_artists = xbmcgui.ListItem(utils.translate(30067))
related_artists.setArt({
'thumb': thumbs.IMG_ARTIST,
'poster': thumbs.IMG_ARTIST
})
items = [
(utils.build_url(url=URL,
paths=['browse', 'artist', artist_id, 'top-songs'],
r_path=True), top_songs, True),
(utils.build_url(
url=URL,
paths=['browse', 'artist', artist_id, 'related-artists'],
r_path=True), related_artists, True)
]
info = GMUSIC.get_artist_info(artist_id=artist_id,
include_albums=True,
max_top_tracks=0,
max_rel_artist=0)
if 'albums' in info:
albums = info['albums']
albums.sort(key=itemgetter('name'))
albums.sort(key=itemgetter('year'), reverse=True)
items += listing.build_album_listitems(albums)
listing.list_albums(items)
else:
listing.list_items([])
def listen_now():
ifl = xbmcgui.ListItem(utils.translate(30045))
ifl.setArt({'thumb': thumbs.IMG_IFL, 'poster': thumbs.IMG_IFL})
albums = xbmcgui.ListItem(utils.translate(30023))
albums.setArt({'thumb': thumbs.IMG_ALBUM, 'poster': thumbs.IMG_ALBUM})
stations = xbmcgui.ListItem(utils.translate(30021))
stations.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
playlists = xbmcgui.ListItem(utils.translate(30020))
playlists.setArt({
'thumb': thumbs.IMG_PLAYLIST,
'poster': thumbs.IMG_PLAYLIST
})
items = [
(utils.build_url(url=URL,
paths=['play', 'station'],
queries={'station_id': 'IFL'},
r_path=True,
r_query=True), ifl, False),
(utils.build_url(URL, ['albums']), albums, True),
(utils.build_url(URL, ['stations']), stations, True),
(utils.build_url(URL, ['playlists']), playlists, True),
]
# Only fetch new information if one full hour has passed
# to keep things speedy on slow devices
try:
last_check = ADDON.getSetting('listen_now_last_update')
except:
last_check = -1
from_cache = True
if last_check != time.strftime('%Y%m%d%H'):
from_cache = False
ADDON.setSetting('listen_now_last_update', time.strftime('%Y%m%d%H'))
primary_header, situations = gmusic.get_listen_now_situations(from_cache)
if primary_header and situations:
situations = xbmcgui.ListItem(primary_header)
situations.setArt({
'thumb': thumbs.IMG_ALBUM,
'poster': thumbs.IMG_ALBUM
})
# Add Situations after IFL
items.insert(1,
(utils.build_url(URL, ['situations']), situations, True))
listing.list_items(items)
def build_artist_listitems(artists, my_library=False):
items = []
for artist in artists:
# Applies to e.g. search results
if 'artist' in artist:
artist = artist['artist']
if 'artistId' not in artist or 'name' not in artist:
continue
artist_id = artist['artistId']
artist_name = artist['name']
artist_art = thumbs.IMG_ARTIST_FLAT
if 'artistArtRef' in artist:
artist_art = artist['artistArtRef']
item = xbmcgui.ListItem(artist_name)
item.setArt({
'thumb': artist_art,
'poster': artist_art,
# 'fanart' : artist_art + '=s1920'
})
item.setInfo('music', {
'mediatype': 'artist',
'artist': artist_name,
})
item.addContextMenuItems(items=[(
utils.translate(30036), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['play', 'station'],
queries={
'station_name': artist_name.encode('utf-8'),
'artist_id': artist_id
},
r_path=True,
r_query=True))])
# My Library entries differ from normal AllAcces ones as users are able
# to add only parts of the item to there library
if my_library:
items.append((utils.build_url(
url=URL,
paths=['browse', 'my-library', 'artist', artist_id],
r_path=True,
r_query=True), item, True))
else:
items.append(
(utils.build_url(url=URL,
paths=['browse', 'artist', artist_id],
r_path=True,
r_query=True), item, True))
return items
def top_charts():
songs = xbmcgui.ListItem(utils.translate(30024))
songs.setArt({'thumb': thumbs.IMG_TRACK, 'poster': thumbs.IMG_TRACK})
albums = xbmcgui.ListItem(utils.translate(30023))
albums.setArt({'thumb': thumbs.IMG_ALBUM, 'poster': thumbs.IMG_ALBUM})
items = [(utils.build_url(URL, ['songs']), songs, True),
(utils.build_url(URL, ['albums']), albums, True)]
listing.list_items(items)
def browse_stations_categories(category_id):
categories = GMUSIC.get_station_categories(True)
if categories:
items = []
for category in categories:
if category['id'] != category_id:
continue
subcategories = category['subcategories']
for sub in subcategories:
item = xbmcgui.ListItem(sub['display_name'])
item.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
items.append((
utils.build_url(
url=URL,
paths=['browse', 'browse-stations',
'subcategories', sub['id']],
r_path=True,
r_query=True
),
item,
True
))
listing.list_items(items)
def _queue(path, play_next=False):
playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
position = len(playlist) + 1
if play_next:
position = playlist.getposition() + 1
query = dict(urlparse.parse_qsl(urlparse.urlparse(URL).query))
if 'play_next' in query:
del query['play_next']
position = playlist.getposition() + 1
utils.execute_jsonrpc(method='Playlist.Insert',
params={
'playlistid': xbmc.PLAYLIST_MUSIC,
'position': position,
'item': {
'directory':
utils.build_url(url=URL,
paths=path,
queries=query,
r_path=True,
r_query=True)
}
})
def queue_track(track_id, track_title='', play_next=False):
track = _get_track_details(track_id)
path = None
item = None
if track:
listitem = listing.build_song_listitems([track])[0]
path = listitem[0]
item = listitem[1]
else:
item = xbmcgui.ListItem(track_title)
item.setArt({'thumb': thumbs.IMG_ALBUM, 'poster': thumbs.IMG_ALBUM})
path = utils.build_url(url=URL,
paths=['play', 'track', track_id],
queries={'track_title': track_title},
r_path=True,
r_query=True)
playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
position = len(playlist) + 1
if play_next:
position = playlist.getposition() + 1
playlist.add(URL=path, listitem=item, index=position)
def my_library_artist(artist_id):
if artist_id:
top_songs = xbmcgui.ListItem(utils.translate(30066))
top_songs.setArt({'thumb': thumbs.IMG_STAR, 'poster': thumbs.IMG_STAR})
related_artists = xbmcgui.ListItem(utils.translate(30067))
related_artists.setArt({
'thumb': thumbs.IMG_ARTIST,
'poster': thumbs.IMG_ARTIST
})
all_albums = xbmcgui.ListItem(utils.translate(30098))
all_albums.setArt({
'thumb': thumbs.IMG_ALBUM,
'poster': thumbs.IMG_ALBUM
})
items = [
(utils.build_url(
url=URL,
paths=['browse', 'artist', artist_id, 'top-songs'],
r_path=True,
r_query=True,
), top_songs, True),
(utils.build_url(
url=URL,
paths=['browse', 'artist', artist_id, 'related-artists'],
r_path=True,
r_query=True,
), related_artists, True),
(utils.build_url(
url=URL,
paths=['browse', 'artist', artist_id],
r_path=True,
r_query=True,
), all_albums, True),
]
albums = GMUSIC.get_user_artist_albums(artist_id=artist_id)
albums.sort(key=itemgetter('name'))
albums.sort(key=itemgetter('year'), reverse=True)
items += listing.build_album_listitems(albums, True)
listing.list_albums(items)
def my_library():
playlists = xbmcgui.ListItem(utils.translate(30020))
playlists.setArt({
'thumb': thumbs.IMG_PLAYLIST,
'poster': thumbs.IMG_PLAYLIST
})
stations = xbmcgui.ListItem(utils.translate(30021))
stations.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
artists = xbmcgui.ListItem(utils.translate(30022))
artists.setArt({'thumb': thumbs.IMG_ARTIST, 'poster': thumbs.IMG_ARTIST})
albums = xbmcgui.ListItem(utils.translate(30023))
albums.setArt({'thumb': thumbs.IMG_ALBUM, 'poster': thumbs.IMG_ALBUM})
songs = xbmcgui.ListItem(utils.translate(30024))
songs.setArt({'thumb': thumbs.IMG_TRACK, 'poster': thumbs.IMG_TRACK})
genres = xbmcgui.ListItem(utils.translate(30025))
genres.setArt({'thumb': thumbs.IMG_GENRE, 'poster': thumbs.IMG_GENRE})
items = [
(utils.build_url(URL, ['playlists']), playlists, True),
(utils.build_url(URL, ['stations']), stations, True),
(utils.build_url(URL, ['artists']), artists, True),
(utils.build_url(URL, ['albums']), albums, True),
(utils.build_url(URL, ['songs']), songs, True),
(utils.build_url(URL, ['genres']), genres, True),
]
listing.list_items(items)
def search_history():
history = _get_search_history()
# Add "New Search" to the list
item = xbmcgui.ListItem(utils.translate(30053))
item.setArt({'thumb': thumbs.IMG_SEARCH, 'poster': thumbs.IMG_SEARCH})
items = [(utils.build_url(url=URL,
paths=['search', 'new'],
r_path=True,
r_query=True), item, True)]
for hist in history:
item = xbmcgui.ListItem(hist)
item.setArt({'thumb': thumbs.IMG_SEARCH, 'poster': thumbs.IMG_SEARCH})
items.append((utils.build_url(url=URL,
paths=['search', hist],
r_path=True,
r_query=True), item, True))
listing.list_items(items)
def my_library_genres():
genres = GMUSIC.get_my_library_genres()
items = []
for genre in genres:
item = xbmcgui.ListItem(genre)
item.setArt({'thumb': thumbs.IMG_GENRE, 'poster': thumbs.IMG_GENRE})
items.append(
(utils.build_url(url=URL,
paths=['browse', 'my-library', 'genre', genre],
r_path=True), item, True))
listing.list_items(items)
def build_situation_listitems(situations):
items = []
for situation in situations:
situation_id = situation['id']
situation_title = situation['title']
situation_art = thumbs.IMG_ALBUM
fanart = None
description = ''
if 'description' in situation:
description = situation['description']
if 'imageUrl' in situation:
situation_art = situation['imageUrl']
if situation_art and situation_art != thumbs.IMG_ALBUM:
fanart = situation_art + "=w1280-w1280"
item = xbmcgui.ListItem(situation_title)
item.setArt({
'thumb': situation_art,
'poster': situation_art,
# 'fanart' : fanart
})
item.setInfo(
'music', {
'mediatype': 'album',
'album': situation_title,
'comment': description,
})
items.append((utils.build_url(
url=URL,
paths=['browse', 'listen-now', 'situation', situation_id],
r_path=True,
r_query=True), item, True))
return items
def browse_stations():
categories = GMUSIC.get_station_categories(False)
items = []
for category in categories:
item = xbmcgui.ListItem(category['display_name'])
item.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
items.append((
utils.build_url(
url=URL,
paths=['browse', 'browse-stations',
'categories', category['id']],
r_path=True,
r_query=True
),
item,
True
))
listing.list_items(items)
def _play(path):
utils.execute_jsonrpc(method='Playlist.Clear',
params={'playlistid': xbmc.PLAYLIST_MUSIC})
utils.execute_jsonrpc(method='Playlist.Add',
params={
'playlistid': xbmc.PLAYLIST_MUSIC,
'item': {
'directory':
utils.build_url(url=URL,
paths=path,
r_path=True)
}
})
utils.execute_jsonrpc(
method='Player.Open',
params={'item': {
'playlistid': xbmc.PLAYLIST_MUSIC,
'position': 0
}})
if ADDON.getSetting('auto_fullscreen') == 'true':
utils.execute_jsonrpc('GUI.SetFullscreen', {'fullscreen': True})
def main_menu():
listen_now = xbmcgui.ListItem(utils.translate(30014))
listen_now.setArt({
'thumb': thumbs.IMG_HEADPHONES,
'poster': thumbs.IMG_HEADPHONES
})
top_charts = xbmcgui.ListItem(utils.translate(30015))
top_charts.setArt({
'thumb': thumbs.IMG_STAR,
'poster': thumbs.IMG_STAR
})
new_releases = xbmcgui.ListItem(utils.translate(30016))
new_releases.setArt({
'thumb': thumbs.IMG_RELEASES,
'poster': thumbs.IMG_RELEASES
})
my_library = xbmcgui.ListItem(utils.translate(30017))
my_library.setArt({
'thumb': thumbs.IMG_LIBRARY,
'poster': thumbs.IMG_LIBRARY
})
browse_stations = xbmcgui.ListItem(utils.translate(30018))
browse_stations.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
search = xbmcgui.ListItem(utils.translate(30019))
search.setArt({
'thumb': thumbs.IMG_SEARCH,
'poster': thumbs.IMG_SEARCH
})
items = [
(
utils.build_url(URL, ['listen-now']),
listen_now,
True
),
(
utils.build_url(URL, ['top-charts']),
top_charts,
True
),
(
utils.build_url(URL, ['new-releases']),
new_releases,
True
),
(
utils.build_url(URL, ['my-library']),
my_library,
True
),
(
utils.build_url(URL, ['browse-stations']),
browse_stations,
True
),
(
utils.build_url(URL, ['search', 'history'], r_path=True),
search,
True
),
]
# Add "Update Library" context menu to "My Library" entry
items[3][1].addContextMenuItems([(
utils.translate(30030),
'XBMC.RunPlugin(%s)' % utils.build_url(
url=URL,
paths=['my-library', 'update'],
r_path=True
)
)])
# Add "Clear search history" context menu to "Search" entry
items[5][1].addContextMenuItems([(
utils.translate(30012),
'XBMC.RunPlugin(%s)' % utils.build_url(
url=URL,
paths=['clear', 'search-history'],
r_path=True
)
)])
listing.list_items(items)
def build_album_listitems(albums, my_library=False):
items = []
for album in albums:
# Applies to e.g. search results
if 'album' in album:
album = album['album']
if 'albumId' not in album or 'name' not in album:
continue
album_id = album['albumId']
album_name = album['name']
album_art = thumbs.IMG_ALBUM
fanart = None
if 'albumArtRef' in album:
album_art = album['albumArtRef']
if album_art and album_art != thumbs.IMG_ALBUM:
fanart = album_art + "=w1280-w1280"
item = xbmcgui.ListItem(album_name)
item.setArt({
'thumb': album_art,
'poster': album_art,
# 'fanart' : fanart
})
item.setInfo(
'music', {
'mediatype': 'album',
'album': album_name,
'artist': album.get('albumArtist', ''),
'genre': album.get('genre', ''),
'year': album.get('year', ''),
})
menu_items = []
if not my_library:
menu_items.append((
utils.translate(30037), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'add', 'album', album_id],
r_path=True,
r_query=True)))
menu_items += [
(utils.translate(30038), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'playlist', 'add'],
queries={'album_id': album_id},
r_path=True,
r_query=True)),
(utils.translate(30036), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['play', 'station'],
queries={
'station_name': album_name.encode('utf-8'),
'album_id': album_id
},
r_path=True,
r_query=True))
]
if 'artistId' in album:
menu_items.append(
(utils.translate(30034),
'Container.Update(%s)' % utils.build_url(
url=URL,
paths=['browse', 'artist', album['artistId'][0]],
r_path=True,
r_query=True)))
if my_library:
menu_items.append(
(utils.translate(30061),
'XBMC.RunPlugin(%s)' % utils.build_url(
url=URL,
paths=['my-library', 'remove', 'album', album_id],
r_path=True,
r_query=True)))
item.addContextMenuItems(items=menu_items)
# My Library entries differ from normal AllAcces ones as users are able
# to add only parts of the item to there library
if my_library:
items.append((utils.build_url(
url=URL,
paths=['browse', 'my-library', 'album', album_id],
r_path=True,
r_query=True), item, True))
else:
items.append((utils.build_url(url=URL,
paths=['browse', 'album', album_id],
r_path=True,
r_query=True), item, True))
return items
def build_song_listitems(tracks,
station_id=None,
my_library=False,
my_library_playlist=False):
tracks_cache = utils.get_cache_dir(['tracks'])
items = []
for elem in tracks:
# Applies to e.g. search results
if 'track' in elem:
track = elem['track']
else:
track = elem
# Try to get an id, otherwise we skip
# Important, always try to get a trackId first, than
# storeId and than id
if 'trackId' in track:
track_id = track['trackId']
elif 'storeId' in track:
track_id = track['storeId']
elif 'id' in track:
track_id = track['id']
else:
continue
# In case of playlists, user uploaded songs come without
# metadata (title, album, etc.)
# All we can do at this point is to check the library cache
# entry and use the informations from there (if it exists)
#
# We only do this if the title is missing as other metadata
# isn't as important and we don't want to do this to often
if 'title' not in track:
_track = GMUSIC.get_my_library_song_details(track_id)
if _track:
track = _track
track_title = track.get('title', '')
album_art = thumbs.IMG_TRACK
fanart = None
if 'albumArtRef' in track and len(track['albumArtRef']) > 0:
album_art = track['albumArtRef'][0]['url']
if 'artistArtRef' in track and len(track['artistArtRef']) > 0:
fanart = track['artistArtRef'][0]['url'] + '=s1920'
item = xbmcgui.ListItem(track_title)
item.setArt({
'thumb': album_art,
'poster': album_art,
# 'fanart' : fanart
})
item.setInfo(
'music', {
'mediatype': 'song',
'title': track_title,
'tracknumber': track('trackNumber', ''),
'year': track('year', ''),
'genre': track('genre', ''),
'album': track('album', ''),
'artist': track('artist', ''),
'rating': track('rating', ''),
'playcount': track('playCount', ''),
})
menu_items = []
if not my_library and 'id' not in track:
# Add "Add to library" to context menu
menu_items.append((
utils.translate(30037), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'add', 'track', track_id],
r_path=True,
r_query=True)))
# Add "Add to playlist" to context menu
menu_items.append(
(utils.translate(30038), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'playlist', 'add'],
queries={'track_id': track_id},
r_path=True,
r_query=True)))
if my_library_playlist:
# Add "Remove from playlist" to context menu
if 'id' in elem:
menu_items.append((
utils.translate(30062), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'playlist', 'remove'],
queries={'entry_id': elem['id']},
r_path=True,
r_query=True)))
# Add "Start radio" to context menu
menu_items.append(
(utils.translate(30036), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['play', 'station'],
queries={
'track_id': track_id,
'station_name': track_title.encode('utf-8')
},
r_path=True,
r_query=True)))
# Add "Go to Artist" to context menu
if 'artistId' in track and len(track['artistId']) > 0:
menu_items.append(
(utils.translate(30034),
'Container.Update(%s)' % utils.build_url(
url=URL,
paths=['browse', 'artist', track['artistId'][0]],
r_path=True,
r_query=True)))
# Add "Go to Album" to context menu
if 'albumId' in track:
menu_items.append(
(utils.translate(30035), 'Container.Update(%s)' %
utils.build_url(url=URL,
paths=['browse', 'album', track['albumId']],
r_path=True,
r_query=True)))
# Add "Rate song" to context menu
menu_items.append((utils.translate(30041), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['rate'],
queries={'track_id': track_id},
r_path=True,
r_query=True)))
if my_library and 'id' in track:
# Add "Remove from library" to context menu
menu_items.append(
(utils.translate(30061),
'XBMC.RunPlugin(%s)' % utils.build_url(
url=URL,
paths=['my-library', 'remove', 'track', track['id']],
r_path=True,
r_query=True)))
item.addContextMenuItems(items=menu_items)
item.setProperty('IsPlayable', 'true')
item.setProperty('Music', 'true')
item.setProperty('mimetype', 'audio/mpeg')
# We cache everything so :play_track: doesn't have to fetch those
# informations again
with open(os.path.join(tracks_cache, track_id), 'w+') as f:
f.write(json.dumps(track))
queries = {}
if station_id:
queries['station_id'] = station_id
items.append((utils.build_url(url=URL,
paths=['play', 'track', track_id],
queries=queries,
r_path=True,
r_query=True), item, False))
# Clean up the tracks directory
for _file in os.listdir(tracks_cache):
_file = os.path.join(tracks_cache, _file)
m_time = os.stat(_file).st_mtime
# If older than 24h we remove it
if m_time < time.time() - 86400:
os.remove(_file)
return items
def build_station_listitems(stations):
items = []
for station in stations:
# Applies to e.g. search results
if 'station' in station:
station = station['station']
if 'name' not in station:
continue
description = ''
if 'description' in station:
description = station['description']
station_name = station['name']
station_art = thumbs.IMG_STATION
fanart = None
if 'imageUrls' in station and len(station['imageUrls']) > 0:
station_art = station['imageUrls'][0]['url']
if station_art and station_art != thumbs.IMG_STATION:
fanart = station_art + "=w1280-w1280"
item = xbmcgui.ListItem(station_name)
item.setArt({
'thumb': station_art,
'poster': station_art,
# 'fanart' : fanart
})
item.setInfo('music', {
'mediatype': 'album',
'album': station_name,
'comment': description,
})
query = {}
if 'id' in station:
query['station_id'] = station['id']
else:
seed = station
if 'seed' in station:
seed = station['seed']
query['station_name'] = station_name.encode('utf-8')
if 'trackId' in seed:
query['track_id'] = seed['trackId']
elif 'artistId' in seed:
query['artist_id'] = seed['artistId']
elif 'albumId' in seed:
query['album_id'] = seed['albumId']
elif 'genreId' in seed:
query['genre_id'] = seed['genreId']
elif 'curatedStationId' in seed:
query['curated_station_id'] = seed['curatedStationId']
else:
continue
items.append((utils.build_url(url=URL,
paths=['play', 'station'],
queries=query,
r_path=True,
r_query=True), item, False))
return items
def build_playlist_listitems(playlists):
items = []
for playlist in playlists:
# Applies to e.g. search results
if 'playlist' in playlist:
playlist = playlist['playlist']
if 'name' not in playlist:
continue
playlist_id = None
playlist_token = None
playlist_name = playlist['name']
playlist_art = thumbs.IMG_PLAYLIST
fanart = None
# Find a thumbnail to be displayed
if 'images' in playlist and len(playlist['images']) > 0:
playlist_art = playlist['images'][0]['url']
elif 'albumArtRef' in playlist and len(playlist['albumArtRef']) > 0:
playlist_art = playlist['albumArtRef'][0]['url']
if playlist_art and playlist_art != thumbs.IMG_PLAYLIST:
fanart = playlist_art + "=w1280-w1280"
# Get the id if available (Would mean it's a user playlist)
if 'id' in playlist and type(playlist['id']) == unicode:
playlist_id = playlist['id']
# Get the shareToken if available
if 'shareToken' in playlist:
playlist_token = playlist['shareToken']
elif 'id' in playlist and 'shareToken' in playlist['id']:
playlist_token = playlist['id']['shareToken']
item = xbmcgui.ListItem(playlist_name)
item.setArt({
'thumb': playlist_art,
'poster': playlist_art,
# 'fanart' : fanart
})
item.setInfo('music', {
'mediatype': 'album',
'album': playlist['name'],
})
paths = []
query = {}
if playlist_id:
paths = ['browse', 'my-library', 'playlist', playlist_id]
elif playlist_token:
paths = ['browse', 'shared-playlist', playlist_token]
query['playlist_token'] = playlist_token
else:
continue
menu_items = []
if playlist_token:
menu_items.append(
(utils.translate(30036), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['play', 'station'],
queries={'playlist_token': playlist_token},
r_path=True,
r_query=True)))
# Add "Delete playlist" to user playlist (Only
# user playlists have a playlist id)
if playlist_id:
menu_items.append(
(utils.translate(30068), 'XBMC.RunPlugin(%s)' %
utils.build_url(url=URL,
paths=['my-library', 'playlist', 'delete'],
queries=query,
r_path=True,
r_query=True)))
item.addContextMenuItems(items=menu_items)
items.append((utils.build_url(url=URL,
paths=paths,
queries=query,
r_path=True,
r_query=True), item, True))
return items
def search(query):
history_file = os.path.join(_CACHE_DIR, 'search_history.json')
history = _get_search_history()
# It was a new search so we add it to the history
if query.decode('utf-8').lower() not in (hist.lower() for hist in history):
history.insert(0, query)
with codecs.open(history_file, 'w+', encoding='utf-8') as f:
f.write(json.dumps(history[:20], indent=2))
result = GMUSIC.search(query)
if not result:
listing.list_items([])
return
items = []
if 'artist_hits' in result and len(result['artist_hits']) > 0:
item = xbmcgui.ListItem(
'%s (%s)' % (utils.translate(30022), len(result['artist_hits'])))
item.setArt({'thumb': thumbs.IMG_ARTIST, 'poster': thumbs.IMG_ARTIST})
items.append((utils.build_url(url=URL,
paths=['search', 'artists', query],
r_path=True,
r_query=True), item, True))
if 'album_hits' in result and len(result['album_hits']) > 0:
item = xbmcgui.ListItem(
'%s (%s)' % (utils.translate(30023), len(result['album_hits'])))
item.setArt({'thumb': thumbs.IMG_ALBUM, 'poster': thumbs.IMG_ALBUM})
items.append((utils.build_url(url=URL,
paths=['search', 'albums', query],
r_path=True,
r_query=True), item, True))
if 'playlist_hits' in result and len(result['playlist_hits']) > 0:
item = xbmcgui.ListItem(
'%s (%s)' % (utils.translate(30020), len(result['playlist_hits'])))
item.setArt({
'thumb': thumbs.IMG_PLAYLIST,
'poster': thumbs.IMG_PLAYLIST
})
items.append((utils.build_url(url=URL,
paths=['search', 'playlists', query],
r_path=True,
r_query=True), item, True))
if 'station_hits' in result and len(result['station_hits']) > 0:
item = xbmcgui.ListItem(
'%s (%s)' % (utils.translate(30021), len(result['station_hits'])))
item.setArt({
'thumb': thumbs.IMG_STATION,
'poster': thumbs.IMG_STATION
})
items.append((utils.build_url(url=URL,
paths=['search', 'stations', query],
r_path=True,
r_query=True), item, True))
if 'song_hits' in result and len(result['song_hits']) > 0:
item = xbmcgui.ListItem(
'%s (%s)' % (utils.translate(30024), len(result['song_hits'])))
item.setArt({'thumb': thumbs.IMG_TRACK, 'poster': thumbs.IMG_TRACK})
items.append((utils.build_url(url=URL,
paths=['search', 'songs', query],
r_path=True,
r_query=True), item, True))
listing.list_items(items)
import sys
import xbmcaddon
# Adds all libraries to our path
# see "resources/libs/lib/__init__.py"
import resources.libs # noqa
ADDON = xbmcaddon.Addon()
ADDON_HANDLE = None
URL = None
if len(sys.argv) > 1:
ADDON_HANDLE = int(sys.argv[1])
URL = sys.argv[0] + sys.argv[2]
if URL == 'plugin://plugin.audio.linuxwhatelse.gmusic/':
from addon import utils
URL = utils.build_url(URL, ['browse'])
