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)