def dialogLoginFailure():
'''Dialog to be shown when we can't login into Qobuz
'''
dialog = xbmcgui.Dialog()
if dialog.yesno(lang(30010), lang(30036), lang(30042)):
qobuz.addon.openSettings()
xbmcplugin.endOfDirectory(
handle=int(sys.argv[1]),
succeeded=False,
updateListing=True,
cacheToDisc=False)
else:
xbmc.executebuiltin('ActivateWindow(home)')
return False
def onInit(self):
if not self.win:
xbmc.executebuiltin(XBMC_DIALOG_BUSY_OPEN)
self.win = xbmcgui.Window(xbmcgui.getCurrentWindowId())
self.sidUpdate()
self.base = self.xnewa.getURL()
self.setOSDMode(True)
self.image = self.getControl(100)
self.debugBack = self.getControl(110)
self.debug = self.getControl(120)
if self.sdlmode != SDL.disabled and self.settings.XNEWA_LIVE_SKIN:
self.win.setProperty('sdlmode', 'true')
else:
self.win.setProperty('sdlmode', 'false')
#self.status = self.getControl(120)
#self.status.setImage('NextPVR.png')
self.getScreen(True)
self.ready = True
xbmc.executebuiltin(XBMC_DIALOG_BUSY_CLOSE)
t = Thread(target=self.render)
t.start()
def onLiveAction(self,actionID,buttonID):
retval = False
if xbmc.Player().isPlayingVideo():
if self.sdlmode != SDL.disabled:
#xbmc.log('video {0} {1}'.format(actionID, buttonID))
if buttonID == 0xf049 or buttonID == 0x1f042 or buttonID == 0x4f042:
# toggle OSD
if self.win.getProperty('showosd') == 'true':
self.setOSDMode(False)
else:
self.setOSDMode(True)
elif (actionID == 26 and buttonID != 0) or buttonID == 0xf023 or buttonID == 0xf054:
#subtitle from remote or #
xbmc.executebuiltin('Action( NextSubtitle )')
retval = True
elif actionID == REMOTE_BACK or actionID == ACTION_BACK or actionID == ACTION_SHOW_GUI:
if self.osdMode == False:
xbmc.executebuiltin('ActivateWindow(fullscreenvideo)')
self.wasFullScreen = True
self.setOSDMode(True)
retval = True
elif actionID == ACTION_PLAYER_FORWARD:
xbmc.executebuiltin('PlayerControl(tempoup)')
retval = True
elif actionID == ACTION_SHOW_OSD or actionID == ACTION_SELECT_ITEM:
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
xbmc.executebuiltin('Action(OSD,fullscreenvideo)')
retval = True
elif actionID == ACTION_PLAYER_REWIND:
xbmc.executebuiltin('PlayerControl(tempodown)')
retval = True
elif actionID == ACTION_BUILT_IN_FUNCTION:
if buttonID == 0xf04d:
#xbmc.executebuiltin('Action(OSD,fullscreenvideo)')
pass
retval = True
elif buttonID == 0xf027 or actionID == ACTION_SMALL_STEP_BACK:
# 'small step'
xbmc.executebuiltin('Seek(-7))')
retval = True
elif buttonID == 0x4f059:
#alt y
xbmc.executebuiltin('ActivateWindow(osdvideosettings)')
retval = True
elif buttonID == 0x4f047 or actionID == 25:
#alt g
xbmc.executebuiltin('ActivateWindow(osdaudiosettings)')
retval = True
elif buttonID == 0xf04f:
xbmc.executebuiltin('ActivateWindow(PlayerProcessInfo)')
retval = True
elif buttonID == 0xf05a or buttonID == 0xf096 or actionID == ACTION_ASPECT_RATIO:
xbmc.executebuiltin('Action(AspectRatio,fullscreenvideo)')
retval = True
elif actionID == ACTION_CONTEXT_MENU and self.settings.XNEWA_CONTEXT_STOP == True:
xbmc.Player().stop()
retval = True
#print 'video pass', actionID, buttonID, retval
else:
xbmc.log('video {0} {1}'.format(actionID, buttonID))
if self.settings.XNEWA_LIVE_SKIN:
self.debug.setLabel('actionID: ' + str(actionID) + ' buttonID: ' + str(hex(buttonID)))
if actionID == REMOTE_BACK:
xbmc.executebuiltin('ActivateWindow(fullscreenvideo)')
self.wasFullScreen = True
self.setOSDMode(True)
retval = True
return retval
def showNotification(message, time_ms=3000, icon_path=None, header=ADDON.getAddonInfo('name')):
try:
icon_path = icon_path or xbmc.translatePath(ADDON.getAddonInfo('icon')).decode('utf-8')
xbmc.executebuiltin('Notification({0},{1},{2},{3})'.format(header, message, time_ms, icon_path))
except RuntimeError: # Happens when disabling the addon
LOG(message)
def Noti(header="",message="",t=10000):
xbmc.executebuiltin(u'Notification("{0}", "{1}", "{2}", "{3}")'.format(header, message, t, ''))
def UpdateLocalAddons(self):
return xbmc.executebuiltin("UpdateLocalAddons")
def autorun_addon():
if xbmcaddon.Addon().getSettingBool("auto_run"):
xbmc.executebuiltin('RunAddon(plugin.video.catchuptvandmore)')
return
def Dialog_CloseAllConfirms(self, *args, **kwargs):
return xbmc.executebuiltin("Dialog.Close(yesnodialog, true)")
def Update(self, url):
if not self.Wait_Window_Loaded():
return
return xbmc.executebuiltin("Container.Update(%s)" % url)
def close_all():
xbmc.executebuiltin('Dialog.Close(all)')
def __init__(self):
xbmc.executebuiltin('ActivateWindow(busydialog)')
def update_container(url):
xbmc.executebuiltin('Container.Update({0})'.format(url))
def __exit__(self, type, value, traceback):
if self.wd is not None:
self.wd.close()
else:
xbmc.executebuiltin('Dialog.Close(busydialog)')
def refresh_container():
xbmc.executebuiltin("XBMC.Container.Refresh")
def __init__(self):
''' Parse the parameters. Reroute to our service.py
where user is fully identified already.
'''
base_url = sys.argv[0]
path = sys.argv[2]
try:
params = dict(parse_qsl(path[1:]))
except Exception:
params = {}
mode = params.get('mode')
server = params.get('server')
if server == 'None':
server = None
LOG.info("path: %s params: %s", path, json.dumps(params, indent=4))
if '/extrafanart' in base_url:
jellyfin_path = path[1:]
jellyfin_id = params.get('id')
get_fanart(jellyfin_id, jellyfin_path, server)
elif '/Extras' in base_url or '/VideoFiles' in base_url:
jellyfin_path = path[1:]
jellyfin_id = params.get('id')
get_video_extras(jellyfin_id, jellyfin_path, server)
elif mode == 'play':
item = TheVoid('GetItem', {
'Id': params['id'],
'ServerId': server
}).get()
Actions(server).play(item,
params.get('dbid'),
params.get('transcode') == 'true',
playlist=params.get('playlist') == 'true')
elif mode == 'playlist':
event('PlayPlaylist', {'Id': params['id'], 'ServerId': server})
elif mode == 'deviceid':
client.reset_device_id()
elif mode == 'reset':
reset()
elif mode == 'delete':
delete_item()
elif mode == 'refreshboxsets':
event('SyncLibrary', {'Id': "Boxsets:Refresh"})
elif mode == 'nextepisodes':
get_next_episodes(params['id'], params['limit'])
elif mode == 'browse':
browse(params.get('type'), params.get('id'), params.get('folder'),
server)
elif mode == 'synclib':
event('SyncLibrary', {'Id': params.get('id')})
elif mode == 'updatelib':
event('SyncLibrary', {'Id': params.get('id'), 'Update': True})
elif mode == 'repairlib':
event('RepairLibrary', {'Id': params.get('id')})
elif mode == 'removelib':
event('RemoveLibrary', {'Id': params.get('id')})
elif mode == 'repairlibs':
event('RepairLibrarySelection')
elif mode == 'updatelibs':
event('SyncLibrarySelection')
elif mode == 'removelibs':
event('RemoveLibrarySelection')
elif mode == 'addlibs':
event('AddLibrarySelection')
elif mode == 'addserver':
event('AddServer')
elif mode == 'login':
event('ServerConnect', {'Id': server})
elif mode == 'removeserver':
event('RemoveServer', {'Id': server})
elif mode == 'settings':
xbmc.executebuiltin('Addon.OpenSettings(plugin.video.jellyfin)')
elif mode == 'adduser':
add_user()
elif mode == 'updateserver':
event('UpdateServer')
elif mode == 'thememedia':
get_themes()
elif mode == 'managelibs':
manage_libraries()
elif mode == 'backup':
backup()
elif mode == 'restartservice':
window('jellyfin.restart.bool', True)
else:
listing()
def play_playlist(self,
items,
clear=True,
seektime=None,
audio=None,
subtitle=None):
''' Play a list of items. Creates a new playlist. Add additional items as plugin listing.
'''
item = items['Items'][0]
playlist = self.get_playlist(item)
player = xbmc.Player()
# xbmc.executebuiltin("Playlist.Clear") # Clear playlist to remove the previous item from playlist position no.2
if clear:
if player.isPlaying():
player.stop()
xbmc.executebuiltin('ActivateWindow(busydialognocancel)')
index = 0
else:
index = max(playlist.getposition(), 0) + 1 # Can return -1
listitem = xbmcgui.ListItem()
LOG.info("[ playlist/%s ] %s", item['Id'], item['Name'])
play = playutils.PlayUtils(item, False, self.server_id, self.server)
source = play.select_source(play.get_sources())
play.set_external_subs(source, listitem)
item['PlaybackInfo']['AudioStreamIndex'] = audio or item[
'PlaybackInfo']['AudioStreamIndex']
item['PlaybackInfo']['SubtitleStreamIndex'] = subtitle or item[
'PlaybackInfo'].get('SubtitleStreamIndex')
self.set_listitem(item, listitem, None, True if seektime else False)
listitem.setPath(item['PlaybackInfo']['Path'])
playutils.set_properties(item, item['PlaybackInfo']['Method'],
self.server_id)
playlist.add(item['PlaybackInfo']['Path'], listitem, index)
index += 1
if clear:
xbmc.executebuiltin('Dialog.Close(busydialognocancel)')
player.play(playlist)
server_address = item['PlaybackInfo']['ServerAddress']
token = item['PlaybackInfo']['Token']
for item in items['Items'][1:]:
listitem = xbmcgui.ListItem()
LOG.info("[ playlist/%s ] %s", item['Id'], item['Name'])
self.set_listitem(item, listitem, None, False)
path = '{}/Audio/{}/stream.mp3?static=true&api_key={}'.format(
server_address, item['Id'], token)
listitem.setPath(path)
playlist.add(path, listitem, index)
index += 1
def log(x):
xbmc.log(repr(x), xbmc.LOGERROR)
def remove_formatting(label):
label = re.sub(r"\[/?[BI]\]", '', label, flags=re.I)
label = re.sub(r"\[/?COLOR.*?\]", '', label, flags=re.I)
return label
#log(sys.argv)
if len(sys.argv) == 1:
xbmc.executebuiltin(
"ActivateWindow(videos,plugin://plugin.video.iptv.archive.downloader)")
quit()
channel = sys.argv[1]
channel = channel.decode("utf8")
channel = channel.encode("utf8")
title = sys.argv[2]
date = sys.argv[3]
duration = sys.argv[4]
plot = sys.argv[5]
dateshort_format = xbmc.getRegion('dateshort')
time_format = xbmc.getRegion('time').replace('%H%H', '%H')
format = "%s %s" % (dateshort_format, time_format.replace(':%S', ''))
#log((date,dateshort_format,time_format,format))
def __exit__(self, type, value, traceback):
xbmc.executebuiltin('Dialog.Close(busydialog)')
def Dialog_CloseAll(self, *args, **kwargs):
return xbmc.executebuiltin("Dialog.Close(all, true)")
def register_client(self,
credentials=None,
options=None,
server_id=None,
server_selection=False):
client = self.get_client(server_id)
self.client = client
self.connect_manager = client.auth
if server_id is None:
client.config.data['app.default'] = True
try:
state = client.authenticate(credentials or {}, options or {})
if state['State'] == CONNECTION_STATE['SignedIn']:
client.callback_ws = event
if server_id is None: # Only assign for default server
client.callback = event
self.get_user(client)
settings('serverName',
client.config.data['auth.server-name'])
settings('server', client.config.data['auth.server'])
event('ServerOnline', {'ServerId': server_id})
event('LoadServer', {'ServerId': server_id})
return state['Credentials']
elif (server_selection
or state['State'] == CONNECTION_STATE['ServerSelection']
or state['State'] == CONNECTION_STATE['Unavailable']
and not settings('SyncInstallRunDone.bool')):
self.select_servers(state)
elif state['State'] == CONNECTION_STATE['ServerSignIn']:
if 'ExchangeToken' not in state['Servers'][0]:
self.login()
elif state['State'] == CONNECTION_STATE['Unavailable'] and state[
'Status_Code'] == 401:
# If the saved credentials don't work, restart the addon to force the password dialog to open
window('jellyfin.restart', clear=True)
elif state['State'] == CONNECTION_STATE['Unavailable']:
raise HTTPException('ServerUnreachable', {})
return self.register_client(state['Credentials'], options,
server_id, False)
except RuntimeError as error:
LOG.exception(error)
xbmc.executebuiltin('Addon.OpenSettings(%s)' % addon_id())
raise Exception('User sign in interrupted')
except HTTPException as error:
if error.status == 'ServerUnreachable':
event('ServerUnreachable', {'ServerId': server_id})
return client.get_credentials()
def Refresh(self):
return xbmc.executebuiltin("Container.Refresh")
'{}: {} - {} to {} - {}'.format(addon.getLocalizedString(30064),
start_date, start_time, end_date,
end_time))
fullStartDate = "{}, {}".format(start_date, start_time)
fullEndDate = "{}, {}".format(end_date, end_time)
start = datetime.strftime(parser.parse(fullStartDate, dayfirst=True),
DATE_FORMAT)
stop = datetime.strftime(parser.parse(fullEndDate, dayfirst=True), DATE_FORMAT)
if (yes_no == 1):
try:
log("Start: {}, End: {}".format(start, stop))
try:
cmd = "PlayMedia(plugin://plugin.video.iptv.archive.downloader/record_epg/%s/%s/%s/%s)" % (
channel, title, start, stop)
xbmc.executebuiltin(cmd)
message = "{}: {} ({} to {})'".format(
xbmc.getInfoLabel("ListItem.ChannelName"),
xbmc.getInfoLabel("ListItem.Label"), start, stop)
except:
xbmcgui.Dialog().notification("IPTV Archive Downloader",
addon.getLocalizedString(30067),
xbmcgui.NOTIFICATION_WARNING)
except Exception as e:
xbmcgui.Dialog().notification("IPTV Archive Downloader",
addon.getLocalizedString(30068),
xbmcgui.NOTIFICATION_ERROR)
log("IPTV Archive Downloader: Error parsing dates ({})".format(e))
def InstallAddon(self, addonId):
return xbmc.executebuiltin("InstallAddon(%s)" % addonId)
def refresh():
xbmc.executebuiltin('Container.Refresh')
def UpdateAddonRepos(self):
return xbmc.executebuiltin("UpdateAddonRepos")
def redirect(location):
xbmc.executebuiltin('Container.Update({},replace)'.format(location))
def notificationDialog(self, message, header=ADDON_NAME, sound=False, time=4000, icon=ICON):
try: xbmcgui.Dialog().notification(header, message, icon, time, sound=False)
except Exception as e:
self.log("notificationDialog Failed! " + str(e), xbmc.LOGERROR)
xbmc.executebuiltin("Notification(%s, %s, %d, %s)" % (header, message, time, icon))
return True
def _executeBuiltin_(function, *args):
xbmc.executebuiltin("{}({})".format(function, ",".join(args)))
def onNotification(self, sender, method, data):
if sender == 'script.plex' and method.endswith('RESTORE'):
from .windows import kodigui
getAdvancedSettings()
populateTimeFormat()
xbmc.executebuiltin('ActivateWindow({0})'.format(kodigui.BaseFunctions.lastWinID))
def executeBuiltin(cmd):
xbmc.executebuiltin(cmd)
def onAction(self, action):
try:
actionID = action.getId()
buttonID = action.getButtonCode()
except: return
if buttonID & 0x1000000:
#these are long presses
if actionID not in CONTEXT_MENU and buttonID not in CONTEXT_MENU:
return
if actionID == ACTION_MOUSE_MOVE:
return
ignoreKeys = ( 61650, 61651, 127184, 127185, 323749, 323796 )
if buttonID in ignoreKeys:
return
if not self.ready or self.renderstop:
return
dt = datetime.datetime.now()
now = int(time.mktime(dt.timetuple()))
if now == self.recent[0]:
if self.recent[1] == 2:
xbmc.log('too fast')
return
self.recent[1] = self.recent[1] + 1
else:
self.recent[0] = now
self.recent[1] = 0
retval = self.onLiveAction(actionID,buttonID)
xbmc.log(str(retval))
if retval == True:
return
self.renderstop = True
self.inControl = True
screenFile = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
keyBase = self.base + '/control?time=' + str(now) + '&key='
url = None
pauseActivity = True
if actionID == ACTION_PLAYER_PLAY:
url = keyBase + str(80|0x20000)
elif actionID == ACTION_STOP:
url = keyBase + str(83|0x20000)
self.state = videoState.stopped
elif actionID == ACTION_NEXT_ITEM:
if buttonID & 0xf046 == 0xf046 :
# NextPVR Ctrl-F
url = keyBase + str(70|0x20000)
else:
url = keyBase + str(39|0x20000)
elif actionID == ACTION_PREV_ITEM:
if '/live?channel=' not in xbmc.Player().getPlayingFile():
url = keyBase + str(37|0x20000)
else:
# send ctrl-w
url = keyBase + str(87|0x20000)
elif actionID == ACTION_PLAYER_FORWARD:
url = keyBase + str(70|0x20000)
elif actionID == ACTION_PLAYER_REWIND:
url = keyBase + str(82|0x20000)
elif actionID == ACTION_FIRST_PAGE or actionID == ACTION_INFO:
#home
if self.state == videoState.playing:
# send ctrl-b
url = keyBase + str(66|0x20000)
else:
url = keyBase + '36'
pauseActivity = False
elif buttonID >= 0x2f041 and buttonID <= 0x2f05a:
url = keyBase + str(buttonID&0xff)
elif buttonID & 0x10000:
ctrl = buttonID&0xff
if ctrl == 0x50:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x53:
url = keyBase + str(ctrl|0x20000)
self.renderstop = False
xbmc.Player().stop()
elif ctrl == 0x4b:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x52:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x82:
url = keyBase + str(37|0x20000)
elif ctrl == 0x83:
url = keyBase + str(39|0x20000)
elif ctrl == 0x42:
url = keyBase + str(80|0x20000)
elif ctrl == 0x46:
url = keyBase + str(70|0x20000)
elif ctrl == 0x57:
url = keyBase + str(87|0x20000)
elif ctrl == 0x47:
url = keyBase + str(112)
elif ctrl == 0x4d and buttonID & 0x30000:
myKey = self.getContext()
if myKey != None:
url = keyBase + myKey
elif ctrl == 0x4f:
url = keyBase + str(119)
elif ctrl == 0x54:
url = keyBase + str(113)
else:
pass
#print actionID, buttonID, hex(ctrl), hex(actionID)
elif actionID == ACTION_RECORD or actionID == ACTION_QUEUE_ITEM:
url = keyBase + str(75|0x20000)
elif actionID == ACTION_PAUSE:
url = keyBase + '32'
elif buttonID == 0xf02e:
url = keyBase + '46'
elif actionID in MOVEMENT_LEFT:
url = keyBase + '37'
elif actionID in MOVEMENT_UP:
url = keyBase + '38'
if xbmc.Player().isPlayingVideo():
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
url = keyBase + str(70|0x20000)
else:
pauseActivity = False
elif actionID in MOVEMENT_RIGHT:
url = keyBase + '39'
elif actionID in MOVEMENT_DOWN or buttonID == 0xf064:
url = keyBase + '40'
if xbmc.Player().isPlayingVideo():
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
url = keyBase + str(82|0x20000)
else:
pauseActivity = False
elif actionID in MOVEMENT_SCROLL_UP:
url = keyBase + '33'
elif actionID in MOVEMENT_SCROLL_DOWN:
url = keyBase + '34'
elif actionID >= 58 and actionID <= 67:
url = keyBase + str(actionID-10)
elif actionID >= 142 and actionID <= 149:
url = keyBase + str(actionID-92)
elif actionID == ACTION_SELECT_ITEM:
url = keyBase + '13'
elif actionID == KEYBOARD_BACK or buttonID == 61575:
url = keyBase + '8'
elif actionID in EXIT_SCRIPT:
url = keyBase + '27'
elif actionID in CONTEXT_MENU or buttonID in CONTEXT_MENU or actionID == ACTION_MOUSE_DOUBLE_CLICK:
myKey = self.getContext()
if myKey != None:
url = keyBase + myKey
elif actionID == ACTION_TELETEXT_RED:
url = keyBase + str(82|0x40000)
elif actionID == ACTION_TELETEXT_GREEN:
url = keyBase + str(71|0x40000)
elif actionID == ACTION_TELETEXT_YELLOW:
url = keyBase + str(89|0x40000)
elif actionID == ACTION_TELETEXT_BLUE:
url = keyBase + str(66|0x40000)
elif buttonID >= 0xf030 and buttonID <= 0xf039:
url = keyBase + str(buttonID-0xf030+48)
elif buttonID >= 0xf041 and buttonID <= 0xf05a:
if self.state == videoState.playing and buttonID == 0xf05a:
buttonID = 118
url = keyBase + str(buttonID&0xff)
elif buttonID >= 0xf090 and buttonID <= 0xf098:
url = keyBase + str((buttonID&0xff)-32)
elif buttonID == 0xf09b:
#F12 exit
self.exitCleanUp()
elif buttonID == 0x4f092:
#alt-f4'
url = keyBase + str(0x40073)
elif buttonID & 0x40000 or buttonID & 0x20000:
buttonID = buttonID | 0x40000
url = keyBase + str(buttonID&0x400ff)
elif actionID == 122 or actionID == 999 :
if buttonID == 50:
#guide
url = keyBase + '112'
elif buttonID == 49 or buttonID == 101:
# recordings
url = keyBase + '119'
elif buttonID == 24:
#live tv
url = keyBase + '113'
elif buttonID == 7:
#my videos
url = keyBase + '114'
elif buttonID == 9:
#my music
url = keyBase + '115'
elif buttonID == 6:
#my pictures
url = keyBase + '116'
elif buttonID == 248:
#my radio
url = keyBase + '117'
elif buttonID == 44:
#subtitle
xbmc.executebuiltin('Action( NextSubtitle )')
elif buttonID == 196:
# power off
self.exitCleanUp()
pass
elif buttonID == 213:
#display
url = keyBase + '119'
else:
xbmc.log('remote action unsupported {0} {1}'.format(actionID, buttonID))
pass
else:
xbmc.log('action unsupported {0} {1}'.format(actionID, buttonID))
pass
if url :
url = url + self.xnewa.client
#while self.rendering:
# time.sleep(0.1)
xbmc.log(url)
try:
jpgfile = urlopen(url)
output = open(screenFile,'wb')
output.write(jpgfile.read())
output.close()
jpgfile.close()
self.setOSDMode(True)
self.image.setImage(screenFile,False)
xbmc.sleep(25)
except HTTPError as err:
xbmc.log(str(err.code))
print(err)
except URLError as err:
print(err)
self.exit = True
self.close()
except Exception as err:
if err.errno != 104 and err.errno != 10054:
print(err)
self.exit = True
self.close()
else:
xbmc.log('ignoring known error')
if pauseActivity:
self.getActivity()
self.renderstop = False
self.inControl = False
self.ready = True
def elementumd_thread(monitor):
restart_count = 0
max_restart = 3
last_code = 0
try:
monitor_abort = xbmc.Monitor() # For Kodi >= 14
while not monitor_abort.abortRequested():
# If we ran out of attempts of last exit code was '-9': we do not try to start it again.
# So if you kill the binary with '-9': it will not be restarted by this monitor.
if restart_count > max_restart or last_code == -9:
if monitor.reboot():
log.debug("elementumd: resetting attempts")
restart_count = 0
last_code = 0
monitor.reboot(False)
else:
time.sleep(5)
continue
log.info("elementumd: starting elementumd")
proc = None
if hasSubprocess:
proc = start_elementumd(stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
if not proc:
break
else:
log.info(
"elementumd: current system is unable to run the binary")
break
threading.Thread(target=wait_for_abortRequested,
args=[proc, monitor]).start()
if not hasSubprocess:
break
if binary_platform["os"] == "windows":
while proc.poll() is None:
log.info(toUtf8(proc.stdout.readline().rstrip()))
else:
# Kodi hangs on some Android (sigh...) systems when doing a blocking
# read. We count on the fact that Elementum daemon flushes its log
# output on \n, creating a pretty clean output
import fcntl
import select
fd = proc.stdout.fileno()
fl = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
while proc.poll() is None:
try:
to_read, _, _ = select.select([proc.stdout], [], [])
for ro in to_read:
line = ro.readline()
if line == "": # write end is closed
break
try:
log.info(toUtf8(line.rstrip()))
except TypeError:
pass
except IOError:
time.sleep(1) # nothing to read, sleep
last_code = proc.returncode
if monitor_abort.abortRequested():
break
if proc.returncode == 0 or proc.returncode == -9 or proc.returncode == -1:
continue
if proc.returncode == 5:
restart_count = 0
notify(getLocalizedString(30332), time=3000)
else:
restart_count += 1
notify(getLocalizedString(30100), time=3000)
xbmc.executebuiltin("Dialog.Close(all, true)")
system_information()
time.sleep(5)
if restart_count >= max_restart:
log.debug("elementumd: no attempts left")
notify(getLocalizedString(30110), time=3000)
continue
except Exception as e:
import traceback
map(log.error, traceback.format_exc().split("\n"))
notify("%s: %s" % (getLocalizedString(30226), repr(e).encode('utf-8')))
raise
log.debug("elementumd: closing")
def OpenDirectory(self, path):
xbmc.executebuiltin('ActivateWindow(Videos,%s)' % path)
def run(url_suffix="", retry=0):
if '/restart/' in sys.argv[0]:
restart_signal()
return
try:
buffer_timeout = int(ADDON.getSetting("buffer_timeout"))
if buffer_timeout < 60:
buffer_timeout = 60
except:
buffer_timeout = 60
buffer_timeout = buffer_timeout * 2
try:
preload_timeout = int(ADDON.getSetting("preload_timeout"))
if preload_timeout < 1:
preload_timeout = 1
except:
preload_timeout = 1
socket.setdefaulttimeout(buffer_timeout)
opener = urllib_request.build_opener(NoRedirectHandler())
opener.addheaders = [('User-Agent', ADDON_ID)]
urllib_request.install_opener(opener)
# Pause currently playing Elementum file to avoid doubling requests
try:
if xbmc.Player().isPlaying() and ADDON_ID in xbmc.Player(
).getPlayingFile():
xbmc.Player().pause()
except:
pass
url = sys.argv[0].replace("plugin://%s" % ADDON_ID,
ELEMENTUMD_HOST + url_suffix) + sys.argv[2]
query_add = ""
if len(sys.argv) > 3:
query_add = sys.argv[3].replace(":", "=")
if query_add and "resume=" not in url:
query_add = query_add.replace("resume=", "doresume=")
if "?" in url:
url += "&" + query_add
else:
url += "?" + query_add
log.debug("Requesting %s from %s" % (url, repr(sys.argv)))
try:
data = _json(url)
except PlayerException as e:
redirect_url = e.__str__()
log.debug("Launching player with %s" % (redirect_url))
xbmcplugin.endOfDirectory(HANDLE, succeeded=True)
xbmc.sleep(500)
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Open","params":{"item":{"file":"%s"}},"id":"1"}'
% (redirect_url))
return
except RedirectException as e:
redirect_url = e.__str__()
log.debug("Redirecting Kodi with %s" % (redirect_url))
xbmcplugin.endOfDirectory(HANDLE, succeeded=True)
xbmc.sleep(500)
if "keyboard=1" in sys.argv[0]:
xbmc.executebuiltin('Container.Update(%s,replace)' %
(redirect_url))
else:
xbmc.executebuiltin('Container.Update(%s)' % (redirect_url))
return
except urllib_error.URLError as e:
# We can retry the request if connection is refused.
# For example when plugin has not yet started but is requested by someone.
if retry <= 2:
time.sleep(preload_timeout)
return run(retry=retry + 1)
if isinstance(e.reason, IOError) or isinstance(
e.reason, OSError) or 'Connection refused' in e.reason:
notify(getLocalizedString(30116), time=7000)
else:
import traceback
map(log.error, traceback.format_exc().split("\n"))
notify(e.reason, time=7000)
return
except Exception as e:
import traceback
log.debug(traceback.print_exc())
map(log.error, traceback.format_exc().split("\n"))
try:
msg = six.ensure_text(e.__str__(), errors='ignore')
except:
try:
msg = six.ensure_binary(e.__str__(), errors='ignore')
except:
msg = repr(e)
notify(getLocalizedLabel(msg), time=7000)
return
if not data:
return
if data["content_type"]:
content_type = data["content_type"]
if data["content_type"].startswith("menus"):
content_type = data["content_type"].split("_")[1]
xbmcplugin.addSortMethod(HANDLE, xbmcplugin.SORT_METHOD_UNSORTED)
if content_type != "tvshows":
xbmcplugin.addSortMethod(HANDLE,
xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE)
else:
xbmcplugin.addSortMethod(HANDLE,
xbmcplugin.SORT_METHOD_TITLE_IGNORE_THE)
xbmcplugin.addSortMethod(HANDLE, xbmcplugin.SORT_METHOD_DATE)
xbmcplugin.addSortMethod(HANDLE, xbmcplugin.SORT_METHOD_GENRE)
xbmcplugin.setContent(HANDLE, content_type)
listitems = list(range(len(data["items"])))
for i, item in enumerate(data["items"]):
# Translate labels
if "LOCALIZE" in item["label"]:
if item["label"][0:8] == "LOCALIZE":
item["label"] = getLocalizedLabel(item["label"])
else:
item["label"] = getLocalizedText(item["label"])
if isinstance(item["label"], str):
item["label"] = six.ensure_text(item["label"], 'utf-8')
if "LOCALIZE" in item["label2"]:
if item["label2"][0:8] == "LOCALIZE":
item["label2"] = getLocalizedText(item["label2"])
else:
item["label2"] = getLocalizedText(item["label2"])
if isinstance(item["label2"], str):
item["label2"] = six.ensure_text(item["label2"], 'utf-8')
if PLATFORM['kodi'] >= 19:
listItem = xbmcgui.ListItem(label=item["label"],
label2=item["label2"])
listItem.setArt({'icon': item["icon"]})
listItem.setArt({'thumb': item["thumbnail"]})
else:
listItem = xbmcgui.ListItem(label=item["label"],
label2=item["label2"],
iconImage=item["icon"],
thumbnailImage=item["thumbnail"])
try:
if item.get("castmembers") and PLATFORM['kodi'] >= 17:
listItem.setCast(item.get("castmembers"))
if item.get("info"):
item["info"] = normalizeLabels(item["info"])
listItem.setInfo("video", item["info"])
if item.get("stream_info"):
for type_, values in item["stream_info"].items():
listItem.addStreamInfo(type_, values)
if item.get("art"):
if "fanarts" in item.get("art") and item.get("art")["fanarts"]:
try:
start = 0
fanart_list = []
for fa in item.get("art")["fanarts"]:
start += 1
item.get("art")["fanart{}".format(start)] = fa
fanart_list.append({'image': fa})
if PLATFORM['kodi'] >= 18:
listItem.setAvailableFanart(fanart_list)
except Exception as e:
log.warning(
"Could not initialize ListItem.Art (%s): %s" %
(repr(item.get("art")), repr(e)))
pass
del item.get("art")["fanarts"]
listItem.setArt(item["art"])
elif ADDON.getSetting('default_fanart') == 'true' and item[
"label"] != six.ensure_text(getLocalizedString(30218),
'utf-8'):
fanart = os.path.join(ADDON_PATH, "fanart.png")
listItem.setArt({'fanart': fanart})
if item.get("context_menu"):
# Translate context menus
for m, menu in enumerate(item["context_menu"]):
if menu[0][0:8] == "LOCALIZE":
menu[0] = getLocalizedLabel(menu[0])
if PLATFORM['kodi'] >= 19 and menu[1][0:5] == "XBMC.":
menu[1] = menu[1][5:]
listItem.addContextMenuItems(item["context_menu"])
listItem.setProperty("isPlayable", item["is_playable"] and "true"
or "false")
if item.get("properties"):
for k, v in item["properties"].items():
listItem.setProperty(k, v)
except Exception as e:
log.warning("Could not initialize ListItem (%s): %s" %
(repr(item.get("info")), repr(e)))
listitems[i] = (item["path"], listItem, not item["is_playable"])
xbmcplugin.addDirectoryItems(HANDLE, listitems, totalItems=len(listitems))
# Set ViewMode
if data["content_type"]:
viewMode = ADDON.getSetting("viewmode_%s" % data["content_type"])
if viewMode:
try:
xbmc.executebuiltin('Container.SetViewMode(%s)' % viewMode)
except Exception as e:
log.warning("Unable to SetViewMode(%s): %s" %
(viewMode, repr(e)))
xbmcplugin.endOfDirectory(HANDLE,
succeeded=True,
updateListing=False,
cacheToDisc=True)
def AddonSettings(self, addonId):
return xbmc.executebuiltin("Addon.OpenSettings(%s)" % addonId)
def _refresh(clear_cache=False):
if clear_cache:
DATA_CACHE.delete_cache(True)
xbmc.executebuiltin('Container.Refresh')
