def start_playback(self):
try:
tools.execute('Dialog.Close(all,true)')
self.current_time = self.getTime()
self.media_length = self.getTotalTime()
if self.offset is not None and int(self.offset) != 0:
tools.log("Seeking %s seconds" % self.offset, 'info')
self.seekTime(self.offset)
self.offset = None
else:
tools.log("No seeking applied")
self.traktStartWatching()
if 'episodeInfo' in self.args and tools.getSetting('smartplay.upnext') == 'true':
source_id = 'plugin.video.%s' % tools.addonName.lower()
return_id = 'plugin.video.%s_play_action' % tools.addonName.lower()
try:
next_info = self.next_info()
AddonSignals.sendSignal('upnext_data', next_info, source_id=source_id)
AddonSignals.registerSlot('upnextprovider', return_id, self.signals_callback)
except:
import traceback
traceback.print_exc()
pass
if tools.getSetting('general.smartplay') is not 'false' and self.media_type is 'episode':
if int(tools.playList.getposition()) == (tools.playList.size() - 1):
self.next_season = smartPlay.SmartPlay(self.args).append_next_season()
self.playback_started = True
except:
pass
def register_addonsignals_slot(callback, signal=None, source_id=None):
"""Register a callback with AddonSignals for return calls"""
name = signal if signal else callback.__name__
AddonSignals.registerSlot(signaler_id=source_id or IPC_ADDON_ID,
signal=name,
callback=callback)
LOG.debug('Registered AddonSignals slot {} to {}'.format(name, callback))
def register_slot(callback, signal=None, source_id=None):
"""Register a callback with AddonSignals for return calls"""
name = signal if signal else _signal_name(callback)
AddonSignals.registerSlot(signaler_id=source_id or g.ADDON_ID,
signal=name,
callback=callback)
debug('Registered AddonSignals slot {} to {}'.format(name, callback))
def onPlayBackStarted(self):
try:
tools.execute('Dialog.Close(all,true)')
self.current_time = self.getTime()
self.media_length = self.getTotalTime()
if self.offset is not None and int(self.offset) != 0:
tools.log("Seeking %s seconds" % self.offset, 'info')
self.seekTime(self.offset)
self.offset = None
else:
tools.log("No seeking applied")
self.traktStartWatching()
if 'episodeInfo' in self.args and tools.getSetting(
'smartplay.upnext') == 'true':
source_id = 'plugin.video.%s' % tools.addonName.lower()
return_id = 'plugin.video.%s_play_action' % tools.addonName.lower(
)
try:
next_info = self.next_info()
AddonSignals.sendSignal('upnext_data',
next_info,
source_id=source_id)
AddonSignals.registerSlot('upnextprovider', return_id,
self.signals_callback)
except:
import traceback
traceback.print_exc()
pass
except:
pass
def __init__(self):
self.downloadCount = 0
self.controller = servicecontrol.ServiceControl()
AddonSignals.registerSlot('script.module.youtube.dl', 'DOWNLOAD_STOP', self.stopDownload)
self.start()
def start_playback(self):
try:
if self.playback_started: return
if not self.isPlayback(): return
self.playback_started = True
self.current_time = self.getTime()
self.media_length = self.getTotalTime()
if self.media_type == 'episode' and control.setting(
'enable.upnext') == 'true':
if int(control.playlist.getposition()) == -1:
control.playlist.clear()
return
source_id = 'plugin.video.venom'
return_id = 'plugin.video.venom_play_action'
try:
if int(control.playlist.getposition()) < (
control.playlist.size() - 1):
if self.media_type is None: return
next_info = self.next_info()
AddonSignals.sendSignal('upnext_data', next_info,
source_id)
AddonSignals.registerSlot('upnextprovider', return_id,
self.signals_callback)
# # Prescrape
# from resources.lib.modules import sources
# psources = sources.Sources().preScrape(title=next_info['next_episode']['title'], year=next_info['next_episode']['year'], imdb=next_info['next_episode']['tvshowimdb'], tvdb=next_info['next_episode']['tvshowid'], season=next_info['next_episode']['season'], episode=next_info['next_episode']['episode'], tvshowtitle=next_info['next_episode']['showtitle'], premiered=next_info['next_episode']['firstaired'])
except:
log_utils.error()
except:
log_utils.error()
def __init__(self):
xbmc.Monitor.__init__(self)
self.tracking = False
self.active_player_id = None
self.action_managers = None
AddonSignals.registerSlot(g.ADDON.getAddonInfo('id'),
common.Signals.PLAYBACK_INITIATED,
self.initialize_playback)
def register_slot(callback, signal=None, source_id=None, is_signal=False):
"""Register a callback with AddonSignals for return calls"""
name = signal if signal else callback.__name__
_callback = (EnvelopeAddonSignalsCallback(callback).call if is_signal else
EnvelopeAddonSignalsCallback(callback).return_call)
AddonSignals.registerSlot(signaler_id=source_id or G.ADDON_ID,
signal=name,
callback=_callback)
LOG.debug('Registered AddonSignals slot {} to {}'.format(name, callback))
def run(self):
startup_delay = kodiUtilities.getSettingAsInt('startup_delay')
if startup_delay:
logger.debug("Delaying startup by %d seconds." % startup_delay)
xbmc.sleep(startup_delay * 1000)
logger.debug("Service thread starting.")
# purge queue before doing anything
self.dispatchQueue.purge()
# setup event driven classes
self.Player = traktPlayer(action=self._dispatchQueue)
self.Monitor = traktMonitor(action=self._dispatchQueue)
# init traktapi class
globals.traktapi = traktAPI()
# init sync thread
self.syncThread = syncThread()
# init scrobbler class
self.scrobbler = Scrobbler(globals.traktapi)
AddonSignals.registerSlot('service.nextup.notification', 'NEXTUPWATCHEDSIGNAL', self.callback)
# start loop for events
while not self.Monitor.abortRequested():
if not kodiUtilities.getSetting('authorization'):
last_reminder = kodiUtilities.getSettingAsInt('last_reminder')
now = int(time.time())
if last_reminder >= 0 and last_reminder < now - (24 * 60 * 60):
gui_utils.get_pin()
while len(self.dispatchQueue) and (not self.Monitor.abortRequested()):
data = self.dispatchQueue.get()
logger.debug("Queued dispatch: %s" % data)
self._dispatch(data)
if xbmc.Player().isPlayingVideo():
self.scrobbler.transitionCheck()
if self.Monitor.waitForAbort(1):
# Abort was requested while waiting. We should exit
break
# we are shutting down
logger.debug("Beginning shut down.")
# delete player/monitor
del self.Player
del self.Monitor
# check if sync thread is running, if so, join it.
if self.syncThread.isAlive():
self.syncThread.join()
def __init__(self):
xbmc.Monitor.__init__(self)
self.scan_in_progress = False
self.scan_awaiting = False
self.startidle = 0
self.last_schedule_check = datetime.now()
AddonSignals.registerSlot(g.ADDON.getAddonInfo('id'),
common.Signals.LIBRARY_UPDATE_REQUESTED,
self.update_kodi_library)
def __init__(self, nx_common):
xbmc.Monitor.__init__(self)
LoggingComponent.__init__(self, nx_common)
self.tracking = False
self.active_player_id = None
self.action_managers = []
AddonSignals.registerSlot(nx_common.addon.getAddonInfo('id'),
Signals.PLAYBACK_INITIATED,
self.initialize_playback)
def run(self):
startup_delay = kodiUtilities.getSettingAsInt('startup_delay')
if startup_delay:
logger.debug("Delaying startup by %d seconds." % startup_delay)
xbmc.sleep(startup_delay * 1000)
logger.debug("Service thread starting.")
# purge queue before doing anything
self.dispatchQueue.purge()
# setup event driven classes
self.Player = traktPlayer(action=self._dispatchQueue)
self.Monitor = traktMonitor(action=self._dispatchQueue)
# init traktapi class
globals.traktapi = traktAPI()
# init sync thread
self.syncThread = syncThread()
# init scrobbler class
self.scrobbler = Scrobbler(globals.traktapi)
AddonSignals.registerSlot('service.nextup.notification',
'NEXTUPWATCHEDSIGNAL', self.callback)
# start loop for events
while not self.Monitor.abortRequested():
while len(self.dispatchQueue) and (
not self.Monitor.abortRequested()):
data = self.dispatchQueue.get()
logger.debug("Queued dispatch: %s" % data)
self._dispatch(data)
if xbmc.Player().isPlayingVideo():
self.scrobbler.transitionCheck()
if self.Monitor.waitForAbort(1):
# Abort was requested while waiting. We should exit
break
# we are shutting down
logger.debug("Beginning shut down.")
# delete player/monitor
del self.Player
del self.Monitor
# check if sync thread is running, if so, join it.
if self.syncThread.isAlive():
self.syncThread.join()
def __init__(self):
# Export new episodes variables
self.startidle = 0
# self.last_schedule_check = datetime.now()
self.next_schedule = _compute_next_schedule()
# Update library variables
xbmc.Monitor.__init__(self)
self.scan_in_progress = False
self.scan_awaiting = False
AddonSignals.registerSlot(
g.ADDON.getAddonInfo('id'), common.Signals.LIBRARY_UPDATE_REQUESTED,
self.update_kodi_library)
def __init__(self, base_url=None, handle=None):
addon = self.get_addon()
self.base_url = base_url
self.handle = handle
self.addon_path = xbmc.translatePath(addon.getAddonInfo('path'))
self.addon_profile = xbmc.translatePath(addon.getAddonInfo('profile'))
self.addon_name = addon.getAddonInfo('id')
self.addon_version = addon.getAddonInfo('version')
self.language = addon.getLocalizedString
self.logging_prefix = '[%s-%s]' % (self.addon_name, self.addon_version)
if not xbmcvfs.exists(self.addon_profile):
xbmcvfs.mkdir(self.addon_profile)
self.r = Ruutu(self.addon_profile, True)
AddonSignals.registerSlot('upnextprovider', self.addon_name + '_play_action', self.play_upnext)
def registerUpNext(self):
source_id = 'plugin.video.%s' % tools.addonName.lower()
return_id = 'plugin.video.%s_play_action' % tools.addonName.lower()
try:
next_info = self.next_info()
AddonSignals.registerSlot('upnextprovider', return_id, self.signals_callback)
AddonSignals.sendSignal('upnext_data', next_info, source_id=source_id)
except RuntimeError:
pass
except:
import traceback
traceback.print_exc()
pass
def register_slot(cls, signaler_id, signal, callback):
# type: (str, str, Callable[[Any], None]) -> None
"""
:param signaler_id:
:param signal:
:param callback:
:return:
"""
if PluginBridge._logger.isEnabledFor(LazyLogger.DEBUG_EXTRA_VERBOSE):
PluginBridge._logger.debug_extra_verbose('signaler_id:',
signaler_id, 'signal:',
signal, 'callback:',
callback.__name__)
Monitor.throw_exception_if_abort_requested()
AddonSignals.registerSlot(signaler_id, signal, callback)
PluginBridge._registered_slots.append((signaler_id, signal))
def __init__(self):
xbmc.Monitor.__init__(self)
try:
self.enabled = G.ADDON.getSettingInt('lib_auto_upd_mode') == 2
except Exception: # pylint: disable=broad-except
# If settings.xml was not created yet, as at first service run
# G.ADDON.getSettingInt('lib_auto_upd_mode') will thrown a TypeError
self.enabled = False
self.startidle = 0
self.next_schedule = _compute_next_schedule()
# Request library update variables
self.scan_in_progress = False
self.scan_awaiting = False
self.clean_in_progress = False
self.clean_awaiting = False
AddonSignals.registerSlot(G.ADDON.getAddonInfo('id'),
common.Signals.REQUEST_KODI_LIBRARY_UPDATE,
self.request_kodi_library_update)
def __init__(self):
try:
self.enabled = g.ADDON.getSettingInt('lib_auto_upd_mode') == 2
except Exception: # pylint: disable=broad-except
# If settings.xml was not created yet, as at first service run
# g.ADDON.getSettingInt('lib_auto_upd_mode') will thrown a TypeError
# If any other error appears, we don't want the service to crash,
# let's return None in all case
self.enabled = False
self.startidle = 0
self.next_schedule = _compute_next_schedule()
# Update library variables
xbmc.Monitor.__init__(self)
self.scan_in_progress = False
self.scan_awaiting = False
AddonSignals.registerSlot(g.ADDON.getAddonInfo('id'),
common.Signals.LIBRARY_UPDATE_REQUESTED,
self.update_kodi_library)
def play_video(self, torrent_url):
"""
Start the torrent's download and play it while being downloaded
:param torrent_url: str
:return: None
"""
xbmc.log(
'PeertubeAddon: Starting torrent download ({0})'.format(
torrent_url), xbmc.LOGDEBUG)
# Start a downloader thread
AddonSignals.sendSignal('start_download', {'url': torrent_url})
# Wait until the PeerTubeDownloader has downloaded all the torrent's metadata
AddonSignals.registerSlot('plugin.video.peertube',
'metadata_downloaded',
self.play_video_continue)
timeout = 0
while self.play == 0 and timeout < 10:
xbmc.sleep(1000)
timeout += 1
# Abort in case of timeout
if timeout == 10:
xbmcgui.Dialog().notification('Download timeout',
'Timeout fetching ' + torrent_url,
xbmcgui.NOTIFICATION_ERROR)
return None
else:
# Wait a little before starting playing the torrent
xbmc.sleep(3000)
# Pass the item to the Kodi player for actual playback.
xbmc.log(
'PeertubeAddon: Starting video playback ({0})'.format(torrent_url),
xbmc.LOGDEBUG)
play_item = xbmcgui.ListItem(path=self.torrent_f)
xbmcplugin.setResolvedUrl(self.plugin_id, True, listitem=play_item)
return None
def start_playback(self):
try:
if self.playback_started:
return
if not self.isPlayback():
return
self.playback_started = True
# control.execute('Dialog.Close(all,true)')
self.current_time = self.getTime()
self.media_length = self.getTotalTime()
if self.media_type == 'episode' and control.setting(
'enable.upnext') == 'true':
if int(control.playlist.getposition()) == -1:
control.playlist.clear()
return
source_id = 'plugin.video.venom'
return_id = 'plugin.video.venom_play_action'
try:
# if int(control.playlist.getposition()) < (control.playlist.size() - 1) and not int(control.playlist.getposition()) == -1:
if int(control.playlist.getposition()) < (
control.playlist.size() - 1):
# log_utils.log('playlist.getposition = %s' % int(control.playlist.getposition()), __name__, log_utils.LOGDEBUG)
if self.media_type is None:
return
next_info = self.next_info()
AddonSignals.sendSignal('upnext_data', next_info,
source_id)
AddonSignals.registerSlot('upnextprovider', return_id,
self.signals_callback)
except:
import traceback
traceback.print_exc()
pass
except:
import traceback
traceback.print_exc()
pass
def run(self):
"""
Main loop of the PeertubeService class, registring the start_download signal to start a
peertubeDownloader thread when needed, and exit when Kodi is shutting down
"""
# Launch the download_torrent callback function when the 'start_download' signal is received
AddonSignals.registerSlot('plugin.video.peertube', 'start_download',
self.download_torrent)
# Monitor Kodi's shutdown signal
xbmc.log('PeertubeService: service started, Waiting for signals',
xbmc.LOGDEBUG)
monitor = xbmc.Monitor()
while not monitor.abortRequested():
if monitor.waitForAbort(1):
# Abort was requested while waiting. We must exit
# TODO: Clean temporary directory
break
return
def start_playback(self):
try:
if self.playback_started:
return
if not self.isPlayback():
return
self.playback_started = True
# control.execute('Dialog.Close(all,true)')
self.current_time = self.getTime()
self.media_length = self.getTotalTime()
if self.media_type == 'episode' and control.setting(
'enable.upnext') == 'true':
source_id = 'plugin.video.ego'
return_id = 'plugin.video.ego_play_action'
try:
if int(control.playlist.getposition()) < (
control.playlist.size() - 1):
if self.media_type is None:
return
next_info = self.next_info()
# xbmc.log('line 469 next_info = %s' % next_info, 2)
AddonSignals.sendSignal('upnext_data', next_info,
source_id)
AddonSignals.registerSlot('upnextprovider', return_id,
self.signals_callback)
except:
import traceback
traceback.print_exc()
pass
except:
import traceback
traceback.print_exc()
pass
def _registering(self):
addon_name = self.addon.getAddonInfo('name')
AddonSignals.registerSlot(addon_name, 'add_skip', self._skips.append)
AddonSignals.registerSlot(addon_name, 'set_next', self.set_next)
import xbmc
import AddonSignals
from resources.lib.functions import setView
def viewNotification(notificationData):
xbmc.log("ViewMasterService viewNotification called:" +
notificationData['view_type'])
setView(notificationData['view_type'])
AddonSignals.registerSlot('embycon', 'display_items', viewNotification)
while not xbmc.abortRequested:
xbmc.sleep(1000)
