1562 lines
45 KiB
Python
1562 lines
45 KiB
Python
#!/usr/bin/python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
import xbmcvfs
|
||
import os
|
||
import xbmcaddon
|
||
import xbmcplugin
|
||
import xbmcgui
|
||
import json
|
||
import shutil
|
||
import time
|
||
import hashlib
|
||
import random
|
||
from datetime import datetime
|
||
from collections.abc import MutableMapping
|
||
from collections import namedtuple
|
||
|
||
# Add the /lib folder to sys
|
||
sys.path.append(xbmcvfs.translatePath(os.path.join(xbmcaddon.Addon("plugin.audio.subsonic").getAddonInfo("path"), "lib")))
|
||
|
||
import libsonic
|
||
|
||
from simpleplugin import Plugin
|
||
from simpleplugin import Addon
|
||
|
||
# Create plugin instance
|
||
plugin = Plugin()
|
||
|
||
connection = None
|
||
cachetime = int(Addon().get_setting('cachetime'))
|
||
|
||
local_starred = set({})
|
||
ListContext = namedtuple('ListContext', ['listing', 'succeeded','update_listing', 'cache_to_disk','sort_methods', 'view_mode','content', 'category'])
|
||
PlayContext = namedtuple('PlayContext', ['path', 'play_item', 'succeeded'])
|
||
def popup(text, time=5000, image=None):
|
||
title = plugin.addon.getAddonInfo('name')
|
||
icon = plugin.addon.getAddonInfo('icon')
|
||
xbmc.executebuiltin('Notification(%s, %s, %d, %s)' % (title, text,
|
||
time, icon))
|
||
|
||
def get_connection():
|
||
global connection
|
||
|
||
if connection==None:
|
||
connected = False
|
||
# Create connection
|
||
try:
|
||
connection = libsonic.Connection(
|
||
baseUrl=Addon().get_setting('subsonic_url'),
|
||
username=Addon().get_setting('username', convert=False),
|
||
password=Addon().get_setting('password', convert=False),
|
||
port=Addon().get_setting('port'),
|
||
apiVersion=Addon().get_setting('apiversion'),
|
||
insecure=Addon().get_setting('insecure'),
|
||
legacyAuth=Addon().get_setting('legacyauth'),
|
||
useGET=Addon().get_setting('useget'),
|
||
)
|
||
connected = connection.ping()
|
||
except:
|
||
pass
|
||
|
||
if connected==False:
|
||
popup('Connection error')
|
||
return False
|
||
|
||
return connection
|
||
|
||
@plugin.action()
|
||
def root(params):
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
menus = {
|
||
'folders': {
|
||
'name': Addon().get_localized_string(30038),
|
||
'callback': 'browse_folders',
|
||
'thumb': None
|
||
},
|
||
'library': {
|
||
'name': Addon().get_localized_string(30019),
|
||
'callback': 'browse_library',
|
||
'thumb': None
|
||
},
|
||
'albums': {
|
||
'name': Addon().get_localized_string(30020),
|
||
'callback': 'menu_albums',
|
||
'thumb': None
|
||
},
|
||
'tracks': {
|
||
'name': Addon().get_localized_string(30021),
|
||
'callback': 'menu_tracks',
|
||
'thumb': None
|
||
},
|
||
'playlists': {
|
||
'name': Addon().get_localized_string(30022),
|
||
'callback': 'list_playlists',
|
||
'thumb': None
|
||
},
|
||
'search': {
|
||
'name': Addon().get_localized_string(30039),
|
||
'callback': 'search',
|
||
'thumb': None
|
||
},
|
||
'searchalbum': {
|
||
'name': Addon().get_localized_string(30045),
|
||
'callback': 'search_album',
|
||
'thumb': None
|
||
},
|
||
}
|
||
|
||
# Iterate through categories
|
||
|
||
for mid in menus:
|
||
|
||
# image
|
||
if 'thumb' in menus[mid]:
|
||
thumb = menus[mid]['thumb']
|
||
|
||
listing.append({
|
||
'label': menus[mid]['name'],
|
||
'thumb': thumb, # Item thumbnail
|
||
'fanart': thumb, # Item thumbnail
|
||
'url': plugin.get_url(
|
||
action=menus[mid]['callback'],
|
||
menu_id=mid
|
||
)
|
||
}) # Item label
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
sort_methods = None,
|
||
))
|
||
|
||
@plugin.action()
|
||
def menu_albums(params):
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
menus = {
|
||
'albums_newest': {
|
||
'name': Addon().get_localized_string(30023),
|
||
'thumb': None,
|
||
'args': {"ltype": "newest"}
|
||
},
|
||
'albums_frequent': {
|
||
'name': Addon().get_localized_string(30024),
|
||
'thumb': None,
|
||
'args': {"ltype": "frequent"}
|
||
},
|
||
'albums_recent': {
|
||
'name': Addon().get_localized_string(30025),
|
||
'thumb': None,
|
||
'args': {"ltype": "recent"}
|
||
},
|
||
'albums_random': {
|
||
'name': Addon().get_localized_string(30026),
|
||
'thumb': None,
|
||
'args': {"ltype": "random"}
|
||
}
|
||
}
|
||
|
||
# Iterate through albums
|
||
|
||
for menu_id in menus:
|
||
|
||
menu = menus.get(menu_id)
|
||
|
||
# image
|
||
if 'thumb' in menu:
|
||
thumb = menu.get('thumb')
|
||
|
||
listing.append({
|
||
'label': menu.get('name'),
|
||
'thumb': menu.get('thumb'), # Item thumbnail
|
||
'fanart': menu.get('thumb'), # Item thumbnail
|
||
'url': plugin.get_url(
|
||
action= 'list_albums',
|
||
page= 1,
|
||
query_args= json.dumps(menu.get('args')),
|
||
menu_id= menu_id
|
||
)
|
||
}) # Item label
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
))
|
||
|
||
@plugin.action()
|
||
def menu_tracks(params):
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
menus = {
|
||
'tracks_starred': {
|
||
'name': Addon().get_localized_string(30036),
|
||
'thumb': None
|
||
},
|
||
'tracks_random': {
|
||
'name': Addon().get_localized_string(30037),
|
||
'thumb': None
|
||
}
|
||
}
|
||
|
||
# Iterate through categories
|
||
|
||
for menu_id in menus:
|
||
|
||
menu = menus.get(menu_id)
|
||
|
||
# image
|
||
if 'thumb' in menu:
|
||
thumb = menu.get('thumb')
|
||
|
||
listing.append({
|
||
'label': menu.get('name'),
|
||
'thumb': menu.get('thumb'), # Item thumbnail
|
||
'fanart': menu.get('thumb'), # Item thumbnail
|
||
'url': plugin.get_url(
|
||
action= 'list_tracks',
|
||
menu_id= menu_id
|
||
)
|
||
}) # Item label
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
))
|
||
|
||
@plugin.action()
|
||
def browse_folders(params):
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
# Get items
|
||
items = walk_folders()
|
||
|
||
# Iterate through items
|
||
for item in items:
|
||
entry = {
|
||
'label': item.get('name'),
|
||
'url': plugin.get_url(
|
||
action= 'browse_indexes',
|
||
folder_id= item.get('id'),
|
||
menu_id= params.get('menu_id')
|
||
|
||
)
|
||
}
|
||
listing.append(entry)
|
||
|
||
if len(listing) == 1:
|
||
plugin.log('One single Media Folder found; do return listing from browse_indexes()...')
|
||
return browse_indexes(params)
|
||
else:
|
||
add_directory_items(create_listing(listing))
|
||
|
||
@plugin.action()
|
||
def browse_indexes(params):
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
# Get items
|
||
# optional folder ID
|
||
folder_id = params.get('folder_id')
|
||
items = walk_index(folder_id)
|
||
|
||
# Iterate through items
|
||
for item in items:
|
||
entry = {
|
||
'label': item.get('name'),
|
||
'url': plugin.get_url(
|
||
action= 'list_directory',
|
||
id= item.get('id'),
|
||
menu_id= params.get('menu_id')
|
||
)
|
||
}
|
||
listing.append(entry)
|
||
|
||
add_directory_items(create_listing(
|
||
listing
|
||
))
|
||
|
||
@plugin.action()
|
||
def list_directory(params):
|
||
# get connection
|
||
connection = get_connection()
|
||
merge_artist = Addon().get_setting('merge')
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
# Get items
|
||
id = params.get('id')
|
||
items = walk_directory(id, merge_artist)
|
||
|
||
# Iterate through items
|
||
for item in items:
|
||
|
||
#is a directory
|
||
if (item.get('isDir')==True):
|
||
entry = {
|
||
'label': item.get('title'),
|
||
'url': plugin.get_url(
|
||
action= 'list_directory',
|
||
id= item.get('id'),
|
||
menu_id= params.get('menu_id')
|
||
)
|
||
}
|
||
else:
|
||
entry = get_entry_track(item,params)
|
||
|
||
|
||
listing.append(entry)
|
||
|
||
add_directory_items(create_listing(
|
||
listing
|
||
))
|
||
|
||
@plugin.action()
|
||
def browse_library(params):
|
||
"""
|
||
List artists from the library (ID3 tags)
|
||
"""
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
# Get items
|
||
items = walk_artists()
|
||
|
||
# Iterate through items
|
||
|
||
for item in items:
|
||
entry = get_entry_artist(item,params)
|
||
|
||
#context menu actions
|
||
context_actions = []
|
||
if can_star('artist',item.get('id')):
|
||
action_star = context_action_star('artist',item.get('id'))
|
||
context_actions.append(action_star)
|
||
|
||
if len(context_actions) > 0:
|
||
entry['context_menu'] = context_actions
|
||
|
||
listing.append(entry)
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
cache_to_disk = True, #cache this view to disk.
|
||
sort_methods = get_sort_methods('artists',params), #he list of integer constants representing virtual folder sort methods.
|
||
content = 'artists' #string - current plugin content, e.g. ‘movies’ or ‘episodes’.
|
||
))
|
||
|
||
@plugin.action()
|
||
def list_albums(params):
|
||
|
||
"""
|
||
List albums from the library (ID3 tags)
|
||
"""
|
||
|
||
listing = []
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
#query
|
||
query_args = {}
|
||
try:
|
||
query_args_json = params['query_args']
|
||
query_args = json.loads(query_args_json)
|
||
except:
|
||
pass
|
||
|
||
#size
|
||
albums_per_page = int(Addon().get_setting('albums_per_page'))
|
||
query_args["size"] = albums_per_page
|
||
|
||
#offset
|
||
offset = int(params.get('page',1)) - 1;
|
||
if offset > 0:
|
||
query_args["offset"] = offset * albums_per_page
|
||
|
||
#debug
|
||
query_args_json = json.dumps(query_args)
|
||
plugin.log('list_albums with args:' + query_args_json);
|
||
|
||
#Get items
|
||
if 'artist_id' in params:
|
||
generator = walk_artist(params.get('artist_id'))
|
||
else:
|
||
generator = walk_albums(**query_args)
|
||
|
||
#make a list out of the generator so we can iterate it several times
|
||
items = list(generator)
|
||
|
||
#check if there==only one artist for this album (and then hide it)
|
||
artists = [item.get('artist',None) for item in items]
|
||
if len(artists) <= 1:
|
||
params['hide_artist'] = True
|
||
|
||
# Iterate through items
|
||
for item in items:
|
||
album = get_entry_album(item, params)
|
||
listing.append(album)
|
||
|
||
# Root menu
|
||
link_root = navigate_root()
|
||
listing.append(link_root)
|
||
|
||
|
||
if not 'artist_id' in params:
|
||
# Pagination if we've not reached the end of the lsit
|
||
# if type(items) != type(True): TO FIX
|
||
link_next = navigate_next(params)
|
||
listing.append(link_next)
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
cache_to_disk = True, #cache this view to disk.
|
||
sort_methods = get_sort_methods('albums',params),
|
||
content = 'albums' #string - current plugin content, e.g. ‘movies’ or ‘episodes’.
|
||
))
|
||
|
||
@plugin.action()
|
||
def list_tracks(params):
|
||
|
||
menu_id = params.get('menu_id')
|
||
listing = []
|
||
|
||
|
||
#query
|
||
query_args = {}
|
||
try:
|
||
query_args_json = params['query_args']
|
||
query_args = json.loads(query_args_json)
|
||
except:
|
||
pass
|
||
|
||
#size
|
||
tracks_per_page = int(Addon().get_setting('tracks_per_page'))
|
||
query_args["size"] = tracks_per_page
|
||
|
||
#offset
|
||
offset = int(params.get('page',1)) - 1;
|
||
if offset > 0:
|
||
query_args["offset"] = offset * tracks_per_page
|
||
|
||
#debug
|
||
query_args_json = json.dumps(query_args)
|
||
plugin.log('list_tracks with args:' + query_args_json);
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
# Album
|
||
if 'album_id' in params:
|
||
generator = walk_album(params['album_id'])
|
||
|
||
# Playlist
|
||
elif 'playlist_id' in params:
|
||
generator = walk_playlist(params['playlist_id'])
|
||
|
||
#TO FIX
|
||
#tracknumber = 0
|
||
#for item in items:
|
||
# tracknumber += 1
|
||
# items[item]['tracknumber'] = tracknumber
|
||
|
||
# Starred
|
||
elif menu_id == 'tracks_starred':
|
||
generator = walk_tracks_starred()
|
||
|
||
|
||
# Random
|
||
elif menu_id == 'tracks_random':
|
||
generator = walk_tracks_random(**query_args)
|
||
# Filters
|
||
#else:
|
||
#TO WORK
|
||
|
||
#make a list out of the generator so we can iterate it several times
|
||
items = list(generator)
|
||
|
||
#check if there==only one artist for this album (and then hide it)
|
||
artists = [item.get('artist',None) for item in items]
|
||
if len(artists) <= 1:
|
||
params['hide_artist'] = True
|
||
|
||
#update stars
|
||
if menu_id == 'tracks_starred':
|
||
ids_list = [item.get('id') for item in items]
|
||
#stars_local_update(ids_list)
|
||
cache_refresh(True)
|
||
|
||
# Iterate through items
|
||
key = 0;
|
||
for item in items:
|
||
track = get_entry_track(item,params)
|
||
listing.append(track)
|
||
key +=1
|
||
|
||
# Root menu
|
||
#link_root = navigate_root()
|
||
#listing.append(link_root)
|
||
|
||
# Pagination if we've not reached the end of the lsit
|
||
# if type(items) != type(True): TO FIX
|
||
#link_next = navigate_next(params)
|
||
#listing.append(link_next)
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
sort_methods= get_sort_methods('tracks',params),
|
||
content = 'songs' #string - current plugin content, e.g. ‘movies’ or ‘episodes’.
|
||
))
|
||
|
||
@plugin.action()
|
||
def list_playlists(params):
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
listing = []
|
||
|
||
# Get items
|
||
items = walk_playlists()
|
||
|
||
# Iterate through items
|
||
|
||
for item in items:
|
||
entry = get_entry_playlist(item,params)
|
||
listing.append(entry)
|
||
|
||
add_directory_items(create_listing(
|
||
listing,
|
||
sort_methods = get_sort_methods('playlists',params), #he list of integer constants representing virtual folder sort methods.
|
||
))
|
||
|
||
@plugin.action()
|
||
def search(params):
|
||
|
||
dialog = xbmcgui.Dialog()
|
||
d = dialog.input(Addon().get_localized_string(30039), type=xbmcgui.INPUT_ALPHANUM)
|
||
|
||
listing = []
|
||
|
||
if d:
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection == False:
|
||
return
|
||
|
||
# Get items
|
||
items = connection.search2(query=d)
|
||
# Iterate through items
|
||
songs = items.get('searchResult2').get('song')
|
||
if songs:
|
||
for item in songs:
|
||
entry = get_entry_track( item, params)
|
||
listing.append(entry)
|
||
|
||
if len(listing) == 0:
|
||
plugin.log('No songs found; do return listing from browse_indexes()...')
|
||
return browse_indexes(params)
|
||
else:
|
||
add_directory_items(create_listing(listing))
|
||
|
||
|
||
@plugin.action()
|
||
def search_album(params):
|
||
|
||
dialog = xbmcgui.Dialog()
|
||
d = dialog.input(Addon().get_localized_string(30045), type=xbmcgui.INPUT_ALPHANUM)
|
||
|
||
listing = []
|
||
|
||
if d:
|
||
# get connection
|
||
connection = get_connection()
|
||
if connection==False:
|
||
return
|
||
# Get items, we are only looking for albums here
|
||
# so artistCount and songCount is set to 0
|
||
items = connection.search2(query=d, artistCount=0, songCount=0)
|
||
# Iterate through items
|
||
|
||
album_list = items.get('searchResult2').get('album')
|
||
if album_list:
|
||
for item in items.get('searchResult2').get('album'):
|
||
entry = get_entry_album( item, params)
|
||
listing.append(entry)
|
||
|
||
# I believe it is ok to return an empty listing if
|
||
# the search gave no result
|
||
# maybe inform the user?
|
||
if len(listing) == 0:
|
||
plugin.log('No albums found; do return listing from browse_indexes()...')
|
||
return browse_indexes(params)
|
||
else:
|
||
add_directory_items(create_listing(listing))
|
||
|
||
|
||
@plugin.action()
|
||
def play_track(params):
|
||
|
||
id = params['id']
|
||
plugin.log('play_track #' + id);
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
url = connection.streamUrl(sid=id,
|
||
maxBitRate=Addon().get_setting('bitrate_streaming'),
|
||
tformat=Addon().get_setting('transcode_format_streaming')
|
||
)
|
||
|
||
#return url
|
||
_set_resolved_url(resolve_url(url))
|
||
|
||
@plugin.action()
|
||
def star_item(params):
|
||
ids= params.get('ids'); #can be single or lists of IDs
|
||
unstar= params.get('unstar',False);
|
||
unstar = (unstar) and (unstar != 'None') and (unstar != 'False') #TO FIX better statement ?
|
||
type= params.get('type');
|
||
sids = albumIds = artistIds = None
|
||
|
||
#validate type
|
||
if type == 'track':
|
||
sids = ids
|
||
elif type == 'artist':
|
||
artistIds = ids
|
||
elif type == 'album':
|
||
albumIds = ids
|
||
|
||
#validate capability
|
||
if not can_star(type,ids):
|
||
return;
|
||
|
||
#validate IDs
|
||
if (not sids and not artistIds and not albumIds):
|
||
return;
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
###
|
||
|
||
did_action = False
|
||
|
||
try:
|
||
if unstar:
|
||
request = connection.unstar(sids, albumIds, artistIds)
|
||
else:
|
||
request = connection.star(sids, albumIds, artistIds)
|
||
if request['status'] == 'ok':
|
||
did_action = True
|
||
|
||
except:
|
||
pass
|
||
|
||
if did_action:
|
||
|
||
if unstar:
|
||
message = Addon().get_localized_string(30031)
|
||
plugin.log('Unstarred %s #%s' % (type,json.dumps(ids)))
|
||
else: #star
|
||
message = Addon().get_localized_string(30032)
|
||
plugin.log('Starred %s #%s' % (type,json.dumps(ids)))
|
||
|
||
#stars_local_update(ids,unstar)
|
||
cache_refresh(True)
|
||
|
||
popup(message)
|
||
|
||
#TO FIX clear starred lists caches ?
|
||
#TO FIX refresh current list after star set ?
|
||
|
||
else:
|
||
if unstar:
|
||
plugin.log_error('Unable to unstar %s #%s' % (type,json.dumps(ids)))
|
||
else:
|
||
plugin.log_error('Unable to star %s #%s' % (type,json.dumps(ids)))
|
||
|
||
#return did_action
|
||
return
|
||
|
||
@plugin.action()
|
||
def download_item(params):
|
||
|
||
id= params.get('id'); #can be single or lists of IDs
|
||
type= params.get('type');
|
||
|
||
#validate path
|
||
download_folder = Addon().get_setting('download_folder')
|
||
|
||
if not download_folder:
|
||
popup("Please set a directory for your downloads")
|
||
plugin.log_error("No directory set for downloads")
|
||
|
||
#validate capability
|
||
if not can_download(type,id):
|
||
return;
|
||
|
||
if type == 'track':
|
||
did_action = download_tracks(id)
|
||
elif type == 'album':
|
||
did_action = download_album(id)
|
||
|
||
if did_action:
|
||
plugin.log('Downloaded %s #%s' % (type,id))
|
||
popup('Item has been downloaded!')
|
||
|
||
else:
|
||
plugin.log_error('Unable to downloaded %s #%s' % (type,id))
|
||
|
||
return did_action
|
||
|
||
def get_entry_playlist(item,params):
|
||
image = connection.getCoverArtUrl(item.get('coverArt'))
|
||
return {
|
||
'label': item.get('name'),
|
||
'thumb': image,
|
||
'fanart': image,
|
||
'url': plugin.get_url(
|
||
action= 'list_tracks',
|
||
playlist_id= item.get('id'),
|
||
menu_id= params.get('menu_id')
|
||
|
||
),
|
||
'info': {'music': { ##http://romanvm.github.io/Kodistubs/_autosummary/xbmcgui.html#xbmcgui.ListItem.setInfo
|
||
'title': item.get('name'),
|
||
'count': item.get('songCount'),
|
||
'duration': item.get('duration'),
|
||
'date': convert_date_from_iso8601(item.get('created'))
|
||
}}
|
||
}
|
||
|
||
def get_artist_info(artist_id, forced=False):
|
||
print("Updating artist info for id: %s"%(artist_id))
|
||
popup("Updating artist info\nplease wait")
|
||
last_update = 0
|
||
artist_info = {}
|
||
cache_file = 'ar-%s'%hashlib.md5(artist_id.encode('utf-8')).hexdigest()
|
||
with plugin.get_storage(cache_file) as storage:
|
||
try:
|
||
last_update = storage['updated']
|
||
except KeyError as e:
|
||
plugin.log("Artist keyerror, is this a new cache file? %s"%cache_file)
|
||
if(time.time()-last_update>(random.randint(1,111)*360) or forced):
|
||
plugin.log("Artist cache expired, updating %s elapsed vs random %s forced %s"%(int(time.time()-last_update),(random.randint(1,111)*3600), forced))
|
||
try:
|
||
artist_info = connection.getArtistInfo2(artist_id).get('artistInfo2')
|
||
storage['artist_info'] = artist_info
|
||
storage['updated']=time.time()
|
||
except AttributeError as e:
|
||
plugin.log("Attribute error, probably couldn't find any info")
|
||
else:
|
||
print("Cache ok for %s retrieving"%artist_id)
|
||
artist_info = storage['artist_info']
|
||
return artist_info
|
||
|
||
def get_entry_artist(item,params):
|
||
image = connection.getCoverArtUrl(item.get('coverArt'))
|
||
#artist_info = get_artist_info(item.get('id'))
|
||
#artist_bio = artist_info.get('biography')
|
||
#fanart = artist_info.get('largeImageUrl')
|
||
fanart = image
|
||
return {
|
||
'label': get_starred_label(item.get('id'),item.get('name')),
|
||
'label2': "test label",
|
||
'offscreen': True,
|
||
'thumb': image,
|
||
'fanart': fanart,
|
||
'url': plugin.get_url(
|
||
action= 'list_albums',
|
||
artist_id= item.get('id'),
|
||
menu_id= params.get('menu_id')
|
||
),
|
||
'info': {
|
||
'music': { ##http://romanvm.github.io/Kodistubs/_autosummary/xbmcgui.html#xbmcgui.ListItem.setInfo
|
||
'count': item.get('albumCount'),
|
||
'artist': item.get('name'),
|
||
#'title': "testtitle",
|
||
#'album': "testalbum",
|
||
#'comment': "testcomment"
|
||
#'title': artist_bio
|
||
}
|
||
}
|
||
}
|
||
|
||
def get_entry_album(item, params):
|
||
|
||
image = connection.getCoverArtUrl(item.get('coverArt'))
|
||
|
||
entry = {
|
||
'label': get_entry_album_label(item,params.get('hide_artist',False)),
|
||
'thumb': image,
|
||
'fanart': image,
|
||
'url': plugin.get_url(
|
||
action= 'list_tracks',
|
||
album_id= item.get('id'),
|
||
hide_artist= item.get('hide_artist'),
|
||
menu_id= params.get('menu_id')
|
||
),
|
||
'info': {
|
||
'music': { ##http://romanvm.github.io/Kodistubs/_autosummary/xbmcgui.html#xbmcgui.ListItem.setInfo
|
||
'count': item.get('songCount'),
|
||
'date': convert_date_from_iso8601(item.get('created')), #date added
|
||
'duration': item.get('duration'),
|
||
'artist': item.get('artist'),
|
||
'album': item.get('name'),
|
||
'year': item.get('year')
|
||
}
|
||
}
|
||
}
|
||
|
||
#context menu actions
|
||
context_actions = []
|
||
|
||
if can_star('album',item.get('id')):
|
||
action_star = context_action_star('album',item.get('id'))
|
||
context_actions.append(action_star)
|
||
|
||
if can_download('album',item.get('id')):
|
||
action_download = context_action_download('album',item.get('id'))
|
||
context_actions.append(action_download)
|
||
|
||
if len(context_actions) > 0:
|
||
entry['context_menu'] = context_actions
|
||
|
||
return entry
|
||
|
||
def get_entry_track(item,params):
|
||
menu_id = params.get('menu_id')
|
||
image = connection.getCoverArtUrl(item.get('coverArt'))
|
||
|
||
entry = {
|
||
'label': get_entry_track_label(item,params.get('hide_artist')),
|
||
'thumb': image,
|
||
'fanart': image,
|
||
'url': plugin.get_url(
|
||
action= 'play_track',
|
||
id= item.get('id'),
|
||
menu_id= menu_id
|
||
),
|
||
'is_playable': True,
|
||
'mime': item.get("contentType"),
|
||
'info': {'music': { #http://romanvm.github.io/Kodistubs/_autosummary/xbmcgui.html#xbmcgui.ListItem.setInfo
|
||
'title': item.get('title'),
|
||
'album': item.get('album'),
|
||
'artist': item.get('artist'),
|
||
'tracknumber': item.get('tracknumber'),
|
||
'year': item.get('year'),
|
||
'genre': item.get('genre'),
|
||
'size': item.get('size'),
|
||
'duration': item.get('duration'),
|
||
'date': item.get('created')
|
||
}
|
||
}
|
||
}
|
||
|
||
#context menu actions
|
||
context_actions = []
|
||
|
||
if can_star('track',item.get('id')):
|
||
action_star = context_action_star('track',item.get('id'))
|
||
context_actions.append(action_star)
|
||
|
||
if can_download('track',item.get('id')):
|
||
action_download = context_action_download('track',item.get('id'))
|
||
context_actions.append(action_download)
|
||
|
||
if len(context_actions) > 0:
|
||
entry['context_menu'] = context_actions
|
||
|
||
|
||
return entry
|
||
|
||
def get_starred_label(id,label):
|
||
if is_starred(id):
|
||
label = '[COLOR=FF00FF00]%s[/COLOR]' % label
|
||
return label
|
||
|
||
def is_starred(id):
|
||
starred = stars_cache_get()
|
||
#id = int(id)
|
||
if id in starred:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def get_entry_track_label(item,hide_artist = False):
|
||
if hide_artist:
|
||
label = item.get('title', '<Unknown>')
|
||
else:
|
||
label = '%s - %s' % (
|
||
item.get('artist', '<Unknown>'),
|
||
item.get('title', '<Unknown>')
|
||
)
|
||
|
||
return get_starred_label(item.get('id'),label)
|
||
|
||
def get_entry_album_label(item,hide_artist = False):
|
||
if hide_artist:
|
||
label = item.get('name', '<Unknown>')
|
||
else:
|
||
label = '%s - %s' % (item.get('artist', '<Unknown>'),
|
||
item.get('name', '<Unknown>'))
|
||
return get_starred_label(item.get('id'),label)
|
||
|
||
def get_sort_methods(type,params):
|
||
#sort method for list types
|
||
#https://github.com/xbmc/xbmc/blob/master/xbmc/SortFileItem.h
|
||
#TO FIX _DATE or _DATEADDED ?
|
||
|
||
#TO FIX
|
||
#actually it seems possible to 'restore' the default sorting (by labels)
|
||
#so our starred items don't get colorized.
|
||
#so do not sort stuff
|
||
#see http://forum.kodi.tv/showthread.php?tid=293037
|
||
return []
|
||
|
||
sortable = [
|
||
xbmcplugin.SORT_METHOD_NONE,
|
||
xbmcplugin.SORT_METHOD_LABEL,
|
||
xbmcplugin.SORT_METHOD_UNSORTED
|
||
]
|
||
|
||
if type=='artists':
|
||
|
||
artists = [
|
||
xbmcplugin.SORT_METHOD_ARTIST
|
||
]
|
||
|
||
sortable = sortable + artists
|
||
|
||
elif type=='albums':
|
||
|
||
albums = [
|
||
xbmcplugin.SORT_METHOD_ALBUM,
|
||
xbmcplugin.SORT_METHOD_DURATION,
|
||
xbmcplugin.SORT_METHOD_DATE,
|
||
#xbmcplugin.SORT_METHOD_YEAR
|
||
]
|
||
|
||
if not params.get('hide_artist',False):
|
||
albums.append(xbmcplugin.SORT_METHOD_ARTIST)
|
||
|
||
sortable = sortable + albums
|
||
|
||
elif type=='tracks':
|
||
|
||
tracks = [
|
||
xbmcplugin.SORT_METHOD_TITLE,
|
||
xbmcplugin.SORT_METHOD_ALBUM,
|
||
xbmcplugin.SORT_METHOD_TRACKNUM,
|
||
#xbmcplugin.SORT_METHOD_YEAR,
|
||
xbmcplugin.SORT_METHOD_GENRE,
|
||
xbmcplugin.SORT_METHOD_SIZE,
|
||
xbmcplugin.SORT_METHOD_DURATION,
|
||
xbmcplugin.SORT_METHOD_DATE,
|
||
xbmcplugin.SORT_METHOD_BITRATE
|
||
]
|
||
|
||
if not params.get('hide_artist',False):
|
||
tracks.append(xbmcplugin.SORT_METHOD_ARTIST)
|
||
|
||
if params.get('playlist_id',False):
|
||
xbmcplugin.SORT_METHOD_PLAYLIST_ORDER,
|
||
|
||
|
||
sortable = sortable + tracks
|
||
|
||
elif type=='playlists':
|
||
|
||
playlists = [
|
||
xbmcplugin.SORT_METHOD_TITLE,
|
||
xbmcplugin.SORT_METHOD_DURATION,
|
||
xbmcplugin.SORT_METHOD_DATE
|
||
]
|
||
|
||
sortable = sortable + playlists
|
||
|
||
return sortable
|
||
|
||
def cache_refresh(forced=False):
|
||
global local_starred
|
||
#cachetime = 5
|
||
last_update = 0
|
||
with plugin.get_storage() as storage:
|
||
#storage['starred_ids'] = starred
|
||
try:
|
||
last_update = storage['updated']
|
||
except KeyError as e:
|
||
plugin.log("keyerror, is this a new cache file?")
|
||
if(time.time()-(cachetime*60)>last_update) or forced:
|
||
plugin.log("Cache expired, updating %s %s %s forced %s"%(time.time(),cachetime*60,last_update, forced))
|
||
generator = walk_tracks_starred()
|
||
items = list(generator)
|
||
ids_list = [item.get('id') for item in items]
|
||
#plugin.log("Retreived from server: %s"%ids_list)
|
||
storage['starred_ids'] = ids_list
|
||
storage['updated']=time.time()
|
||
plugin.log("cache_refresh checking length of load to local %s items"%len(ids_list))
|
||
local_starred = ids_list
|
||
else:
|
||
#plugin.log("Cache fresh %s %s %s forced %s remaining %s"%(time.time(),cachetime*60,last_update, forced, time.time()-(cachetime*60)-last_update))
|
||
pass
|
||
if(len(local_starred)==0):
|
||
local_starred = storage['starred_ids']
|
||
#plugin.log("cache_refresh returning %s items"%len(local_starred))
|
||
return
|
||
|
||
def stars_cache_get():
|
||
global local_starred
|
||
cache_refresh()
|
||
return local_starred
|
||
|
||
def navigate_next(params):
|
||
|
||
page = int(params.get('page',1))
|
||
page += 1
|
||
|
||
title = Addon().get_localized_string(30029) +"(%d)" % (page)
|
||
|
||
return {
|
||
'label': title,
|
||
'url': plugin.get_url(
|
||
action= params.get('action',None),
|
||
page= page,
|
||
query_args= params.get('query_args',None)
|
||
)
|
||
}
|
||
|
||
def navigate_root():
|
||
return {
|
||
'label': Addon().get_localized_string(30030),
|
||
'url': plugin.get_url(action='root')
|
||
}
|
||
|
||
#converts a date string from eg. '2012-04-17T19:53:44' to eg. '17.04.2012'
|
||
def convert_date_from_iso8601(iso8601):
|
||
format = "%Y-%m-%dT%H:%M:%S"
|
||
try:
|
||
date_obj = datetime.strptime(iso8601.split(".")[0], format)
|
||
except TypeError:
|
||
date_obj = datetime(*(time.strptime(iso8601.split(".")[0], format)[0:6]))
|
||
return date_obj.strftime('%d.%m.%Y')
|
||
|
||
def context_action_star(type,id):
|
||
|
||
starred = is_starred(id)
|
||
|
||
if not starred:
|
||
|
||
label = Addon().get_localized_string(30033)
|
||
|
||
else:
|
||
|
||
#Should be available only in the stars lists;
|
||
#so we don't have to fetch the starred status for each item
|
||
#(since it is not available into the XML response from the server)
|
||
|
||
label = Addon().get_localized_string(30034)
|
||
|
||
xbmc.log('Context action star returning RunPlugin(%s)' % plugin.get_url(action='star_item',type=type,ids=id,unstar=starred),xbmc.LOGDEBUG)
|
||
return (
|
||
label,
|
||
'RunPlugin(%s)' % plugin.get_url(action='star_item',type=type,ids=id,unstar=starred)
|
||
)
|
||
|
||
#Subsonic API says this==supported for artist,tracks and albums,
|
||
#But I can see it available only for tracks on Subsonic 5.3, so disable it.
|
||
def can_star(type,ids = None):
|
||
|
||
if not ids:
|
||
return False
|
||
|
||
if not isinstance(ids, list) or isinstance(ids, tuple):
|
||
ids = [ids]
|
||
if len(ids) == 0:
|
||
return False
|
||
|
||
if type == 'track':
|
||
return True
|
||
elif type == 'artist':
|
||
return False
|
||
elif type == 'album':
|
||
return False
|
||
|
||
|
||
def context_action_download(type,id):
|
||
|
||
label = Addon().get_localized_string(30035)
|
||
|
||
return (
|
||
label,
|
||
'RunPlugin(%s)' % plugin.get_url(action='download_item',type=type,id=id)
|
||
)
|
||
|
||
def can_download(type,id = None):
|
||
if id==None:
|
||
return False
|
||
|
||
if type == 'track':
|
||
return True
|
||
elif type == 'album':
|
||
return True
|
||
|
||
def download_tracks(ids):
|
||
|
||
#popup==fired before, in download_item
|
||
download_folder = Addon().get_setting('download_folder')
|
||
if not download_folder:
|
||
return
|
||
|
||
if not ids:
|
||
return False
|
||
|
||
#make list
|
||
if not isinstance(ids, list) or isinstance(ids, tuple):
|
||
ids = [ids]
|
||
|
||
|
||
ids_count = len(ids)
|
||
|
||
#check if empty
|
||
if ids_count == 0:
|
||
return False
|
||
|
||
plugin.log('download_tracks IDs:')
|
||
plugin.log(json.dumps(ids))
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
#progress...
|
||
pc_step = 100/ids_count
|
||
pc_progress = 0
|
||
ids_parsed = 0
|
||
progressdialog = xbmcgui.DialogProgress()
|
||
progressdialog.create("Downloading tracks...") #Title
|
||
|
||
for id in ids:
|
||
|
||
if (progressdialog.iscanceled()):
|
||
return False
|
||
|
||
# debug
|
||
plugin.log('Trying to download track #'+str(id))
|
||
|
||
# get track infos
|
||
response = connection.getSong(id);
|
||
track = response.get('song')
|
||
plugin.log('Track info :')
|
||
plugin.log(track)
|
||
|
||
# progress bar
|
||
pc_progress = ids_parsed * pc_step
|
||
progressdialog.update(pc_progress, 'Getting track informations...',get_entry_track_label(track))
|
||
|
||
track_path_relative = track.get("path", None).encode('utf8', 'replace') # 'Radiohead/Kid A/Idioteque.mp3'
|
||
track_path = os.path.join(download_folder, track_path_relative) # 'C:/users/.../Radiohead/Kid A/Idioteque.mp3'
|
||
track_directory = os.path.dirname(os.path.abspath(track_path)) # 'C:/users/.../Radiohead/Kid A'
|
||
|
||
#check if file exists
|
||
if os.path.isfile(track_path):
|
||
|
||
progressdialog.update(pc_progress, 'Track has already been downloaded!')
|
||
plugin.log("File '%s' already exists" % (id))
|
||
|
||
else:
|
||
|
||
progressdialog.update(pc_progress, "Downloading track...",track_path)
|
||
|
||
try:
|
||
#get remote file (file-object like)
|
||
file_obj = connection.download(id)
|
||
|
||
#create directory if it does not exists
|
||
if not os.path.exists(track_directory):
|
||
os.makedirs(track_directory)
|
||
|
||
#create blank file
|
||
file = open(track_path, 'a') #create a new file but don't erase the existing one if it exists
|
||
|
||
#fill blank file
|
||
shutil.copyfileobj(file_obj, file)
|
||
file.close()
|
||
|
||
except:
|
||
popup("Error while downloading track #%s" % (id))
|
||
plugin.log("Error while downloading track #%s" % (id))
|
||
pass
|
||
|
||
ids_parsed += 1
|
||
|
||
progressdialog.update(100, "Done !","Enjoy !")
|
||
xbmc.sleep(1000)
|
||
progressdialog.close()
|
||
|
||
def download_album(id):
|
||
|
||
# get connection
|
||
connection = get_connection()
|
||
|
||
if connection==False:
|
||
return
|
||
|
||
# get album infos
|
||
response = connection.getAlbum(id);
|
||
album = response.get('album')
|
||
tracks = album.get('song')
|
||
|
||
plugin.log('getAlbum:')
|
||
plugin.log(json.dumps(album))
|
||
|
||
ids = [] #list of track IDs
|
||
|
||
for i, track in enumerate(tracks):
|
||
track_id = track.get('id')
|
||
ids.append(track_id)
|
||
|
||
download_tracks(ids)
|
||
|
||
def create_listing(listing, succeeded=True, update_listing=False, cache_to_disk=False, sort_methods=None,view_mode=None, content=None, category=None):
|
||
return ListContext(listing, succeeded, update_listing, cache_to_disk,sort_methods, view_mode, content, category)
|
||
|
||
def resolve_url(path='', play_item=None, succeeded=True):
|
||
"""
|
||
Create and return a context dict to resolve a playable URL
|
||
:param path: the path to a playable media.
|
||
:type path: str or unicode
|
||
:param play_item: a dict of item properties as described in the class docstring.
|
||
It allows to set additional properties for the item being played, like graphics, metadata etc.
|
||
if ``play_item`` parameter==present, then ``path`` value==ignored, and the path must be set via
|
||
``'path'`` property of a ``play_item`` dict.
|
||
:type play_item: dict
|
||
:param succeeded: if ``False``, Kodi won't play anything
|
||
:type succeeded: bool
|
||
:return: context object containing necessary parameters
|
||
for Kodi to play the selected media.
|
||
:rtype: PlayContext
|
||
"""
|
||
return PlayContext(path, play_item, succeeded)
|
||
|
||
def create_list_item(item):
|
||
"""
|
||
Create an :class:`xbmcgui.ListItem` instance from an item dict
|
||
:param item: a dict of ListItem properties
|
||
:type item: dict
|
||
:return: ListItem instance
|
||
:rtype: xbmcgui.ListItem
|
||
"""
|
||
major_version = xbmc.getInfoLabel('System.BuildVersion')[:2]
|
||
if major_version >= '18':
|
||
list_item = xbmcgui.ListItem(label=item.get('label', ''),
|
||
label2=item.get('label2', ''),
|
||
path=item.get('path', ''),
|
||
offscreen=item.get('offscreen', False))
|
||
|
||
|
||
art = item.get('art', {})
|
||
art['thumb'] = item.get('thumb', '')
|
||
art['icon'] = item.get('icon', '')
|
||
art['fanart'] = item.get('fanart', '')
|
||
item['art'] = art
|
||
cont_look = item.get('content_lookup')
|
||
if cont_look is not None:
|
||
list_item.setContentLookup(cont_look)
|
||
if item.get('art'):
|
||
list_item.setArt(item['art'])
|
||
if item.get('stream_info'):
|
||
for stream, stream_info in item['stream_info'].items():
|
||
list_item.addStreamInfo(stream, stream_info)
|
||
if item.get('info'):
|
||
for media, info in item['info'].items():
|
||
list_item.setInfo(media, info)
|
||
if item.get('context_menu') is not None:
|
||
list_item.addContextMenuItems(item['context_menu'])
|
||
if item.get('subtitles'):
|
||
list_item.setSubtitles(item['subtitles'])
|
||
if item.get('mime'):
|
||
list_item.setMimeType(item['mime'])
|
||
if item.get('properties'):
|
||
for key, value in item['properties'].items():
|
||
list_item.setProperty(key, value)
|
||
if major_version >= '17':
|
||
cast = item.get('cast')
|
||
if cast is not None:
|
||
list_item.setCast(cast)
|
||
db_ids = item.get('online_db_ids')
|
||
if db_ids is not None:
|
||
list_item.setUniqueIDs(db_ids)
|
||
ratings = item.get('ratings')
|
||
if ratings is not None:
|
||
for rating in ratings:
|
||
list_item.setRating(**rating)
|
||
return list_item
|
||
|
||
def _set_resolved_url(context):
|
||
plugin.log_debug('Resolving URL from {0}'.format(str(context)))
|
||
if context.play_item==None:
|
||
list_item = xbmcgui.ListItem(path=context.path)
|
||
else:
|
||
list_item = self.create_list_item(context.play_item)
|
||
xbmcplugin.setResolvedUrl(plugin.handle, context.succeeded, list_item)
|
||
|
||
|
||
def add_directory_items(context):
|
||
plugin.log_debug('Creating listing from {0}'.format(str(context)))
|
||
if context.category is not None:
|
||
xbmcplugin.setPluginCategory(plugin.handle, context.category)
|
||
if context.content is not None:
|
||
xbmcplugin.setContent(plugin.handle, context.content) # This must be at the beginning
|
||
for item in context.listing:
|
||
is_folder = item.get('is_folder', True)
|
||
if item.get('list_item') is not None:
|
||
list_item = item['list_item']
|
||
else:
|
||
list_item = create_list_item(item)
|
||
if item.get('is_playable'):
|
||
list_item.setProperty('IsPlayable', 'true')
|
||
is_folder = False
|
||
xbmcplugin.addDirectoryItem(plugin.handle, item['url'], list_item, is_folder)
|
||
if context.sort_methods is not None:
|
||
if isinstance(context.sort_methods, (int, dict)):
|
||
sort_methods = [context.sort_methods]
|
||
elif isinstance(context.sort_methods, (tuple, list)):
|
||
sort_methods = context.sort_methods
|
||
else:
|
||
raise TypeError(
|
||
'sort_methods parameter must be of int, dict, tuple or list type!')
|
||
for method in sort_methods:
|
||
if isinstance(method, int):
|
||
xbmcplugin.addSortMethod(plugin.handle, method)
|
||
elif isinstance(method, dict):
|
||
xbmcplugin.addSortMethod(plugin.handle, **method)
|
||
else:
|
||
raise TypeError(
|
||
'method parameter must be of int or dict type!')
|
||
|
||
xbmcplugin.endOfDirectory(plugin.handle,
|
||
context.succeeded,
|
||
context.update_listing,
|
||
context.cache_to_disk)
|
||
if context.view_mode is not None:
|
||
xbmc.executebuiltin('Container.SetViewMode({0})'.format(context.view_mode))
|
||
|
||
def walk_index(folder_id=None):
|
||
"""
|
||
Request Subsonic's index and iterate each item.
|
||
"""
|
||
response = connection.getIndexes(folder_id)
|
||
plugin.log("Walk index resp: %s"%response)
|
||
try:
|
||
for index in response["indexes"]["index"]:
|
||
for artist in index["artist"]:
|
||
plugin.log("artist: %s"%artist)
|
||
yield artist
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_playlists():
|
||
"""
|
||
Request Subsonic's playlists and iterate over each item.
|
||
"""
|
||
response = connection.getPlaylists()
|
||
try:
|
||
for child in response["playlists"]["playlist"]:
|
||
yield child
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_playlist(playlist_id):
|
||
"""
|
||
Request Subsonic's playlist items and iterate over each item.
|
||
"""
|
||
response = connection.getPlaylist(playlist_id)
|
||
try:
|
||
for child in response["playlist"]["entry"]:
|
||
yield child
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_folders():
|
||
response = connection.getMusicFolders()
|
||
try:
|
||
for child in response["musicFolders"]["musicFolder"]:
|
||
yield child
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_directory(directory_id, merge_artist = True):
|
||
"""
|
||
Request a Subsonic music directory and iterate over each item.
|
||
"""
|
||
response = connection.getMusicDirectory(directory_id)
|
||
|
||
try:
|
||
for child in response["directory"]["child"]:
|
||
if merge_artist and child.get("isDir"):
|
||
for child in walk_directory(child["id"], merge_artist):
|
||
yield child
|
||
else:
|
||
yield child
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_artist(artist_id):
|
||
"""
|
||
Request a Subsonic artist and iterate over each album.
|
||
"""
|
||
|
||
response = connection.getArtist(artist_id)
|
||
try:
|
||
for child in response["artist"]["album"]:
|
||
yield child
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_artists():
|
||
"""
|
||
(ID3 tags)
|
||
Request all artists and iterate over each item.
|
||
"""
|
||
response = connection.getArtists()
|
||
try:
|
||
for index in response["artists"]["index"]:
|
||
for artist in index["artist"]:
|
||
yield artist
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_genres():
|
||
"""
|
||
(ID3 tags)
|
||
Request all genres and iterate over each item.
|
||
"""
|
||
response = connection.getGenres()
|
||
try:
|
||
for genre in response["genres"]["genre"]:
|
||
yield genre
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_albums(ltype, size=None, fromYear=None,toYear=None, genre=None, offset=None):
|
||
"""
|
||
(ID3 tags)
|
||
Request all albums for a given genre and iterate over each album.
|
||
"""
|
||
|
||
if ltype == 'byGenre' and genre is None:
|
||
return
|
||
|
||
if ltype == 'byYear' and (fromYear is None or toYear is None):
|
||
return
|
||
|
||
response = connection.getAlbumList2(
|
||
ltype=ltype, size=size, fromYear=fromYear, toYear=toYear,genre=genre, offset=offset)
|
||
|
||
if not response["albumList2"]["album"]:
|
||
return
|
||
|
||
for album in response["albumList2"]["album"]:
|
||
yield album
|
||
|
||
|
||
def walk_album(album_id):
|
||
"""
|
||
(ID3 tags)
|
||
Request an album and iterate over each item.
|
||
"""
|
||
response = connection.getAlbum(album_id)
|
||
try:
|
||
for song in response["album"]["song"]:
|
||
yield song
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_tracks_random(size=None, genre=None, fromYear=None,toYear=None):
|
||
"""
|
||
Request random songs by genre and/or year and iterate over each song.
|
||
"""
|
||
response = connection.getRandomSongs(
|
||
size=size, genre=genre, fromYear=fromYear, toYear=toYear)
|
||
try:
|
||
for song in response["randomSongs"]["song"]:
|
||
yield song
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
def walk_tracks_starred():
|
||
"""
|
||
Request Subsonic's starred songs and iterate over each item.
|
||
"""
|
||
response = connection.getStarred()
|
||
try:
|
||
for song in response["starred"]["song"]:
|
||
yield song
|
||
except KeyError:
|
||
yield from ()
|
||
|
||
# Start plugin from within Kodi.
|
||
if __name__ == "__main__":
|
||
# Map actions
|
||
# Note that we map callable objects without brackets ()
|
||
plugin.run()
|