def settingOptionsFillerViews(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # retrieve the media import mediaImport = xbmcmediaimport.getImport(handle) if not mediaImport: log('cannot retrieve media import', xbmc.LOGERROR) return # prepare the media provider settings if not mediaProvider.prepareSettings(): log('cannot prepare media provider settings', xbmc.LOGERROR) return embyServer = Server(mediaProvider) if not embyServer.Authenticate(): log('failed to authenticate on media provider {}'.format(mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return libraryViews = Library.GetViews(embyServer, mediaImport.getMediaTypes()) views = [] for libraryView in libraryViews: views.append((libraryView.name, libraryView.id)) # get the import's settings settings = mediaImport.getSettings() # pass the list of views back to Kodi settings.setStringOptions(emby.constants.SETTING_IMPORT_VIEWS_SPECIFIC, views)
def isImportReady(handle, options): # retrieve the media import mediaImport = xbmcmediaimport.getImport(handle) if not mediaImport: log('cannot retrieve media import', xbmc.LOGERROR) return # prepare and get the media import settings importSettings = mediaImport.prepareSettings() if not importSettings: log('cannot prepare media import settings', xbmc.LOGERROR) return # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # prepare the media provider settings if not mediaProvider.prepareSettings(): log('cannot prepare media provider settings', xbmc.LOGERROR) return embyServer = None try: embyServer = Server(mediaProvider) except: return importReady = False # check if authentication works with the current provider settings if embyServer.Authenticate(): # check if the chosen library views exist selectedViews = getLibraryViewsFromSettings(importSettings) matchingViews = getMatchingLibraryViews(embyServer, mediaImport.getMediaTypes(), selectedViews) importReady = len(matchingViews) > 0 xbmcmediaimport.setImportReady(handle, importReady)
class ProviderObserver: class Action: Start = 0 Stop = 1 def __init__(self): # default values self._actions = [] self._connected = False self._imports = [] self._mediaProvider = None self._settings = None self._server = None self._websocket = None def __del__(self): self._StopAction() def AddImport(self, mediaImport): if not mediaImport: raise ValueError('invalid mediaImport') # look for a matching import matchingImportIndices = self._FindImportIndices(mediaImport) # if a matching import has been found update it if matchingImportIndices: self._imports[matchingImportIndices[0]] = mediaImport ProviderObserver.log('media import {} from {} updated'.format( mediaImport2str(mediaImport), mediaProvider2str(self._mediaProvider))) else: # otherwise add the import to the list self._imports.append(mediaImport) ProviderObserver.log('media import {} from {} added'.format( mediaImport2str(mediaImport), mediaProvider2str(self._mediaProvider))) def RemoveImport(self, mediaImport): if not mediaImport: raise ValueError('invalid mediaImport') # look for a matching import matchingImportIndices = self._FindImportIndices(mediaImport) if not matchingImportIndices: return # remove the media import from the list del self._imports[matchingImportIndices[0]] ProviderObserver.log('media import {} from {} removed'.format( mediaImport2str(mediaImport), mediaProvider2str(self._mediaProvider))) def Start(self, mediaProvider): if not mediaProvider: raise ValueError('invalid mediaProvider') self._actions.append((ProviderObserver.Action.Start, mediaProvider)) def Stop(self): self._actions.append((ProviderObserver.Action.Stop, None)) def Process(self): # process any open actions self._ProcessActions() # process any incoming messages self._ProcessMessages() def _FindImportIndices(self, mediaImport): if not mediaImport: raise ValueError('invalid mediaImport') return [ i for i, x in enumerate(self._imports) if x.getPath() == mediaImport.getPath() and x.getMediaTypes() == mediaImport.getMediaTypes() ] def _ProcessActions(self): for (action, data) in self._actions: if action == ProviderObserver.Action.Start: self._StartAction(data) elif action == ProviderObserver.Action.Stop: self._StopAction() else: ProviderObserver.log( 'unknown action {} to process'.format(action), xbmc.LOGWARNING) self._actions = [] def _ProcessMessages(self): # nothing to do if we are not connected to an Emby server if not self._connected: return while True: try: message = self._websocket.recv() if message is None: break messageObj = json.loads(message) if not messageObj: ProviderObserver.log( 'invalid JSON message ({}) from {} received: {}'. format(len(message), mediaProvider2str(self._mediaProvider), message), xbmc.LOGWARNING) continue self._ProcessMessage(messageObj) except websocket.WebSocketTimeoutException: break except Exception as error: ProviderObserver.log( 'unknown exception when receiving data from {}: {}'.format( mediaProvider2str(self._mediaProvider), error.args[0]), xbmc.LOGWARNING) break def _ProcessMessage(self, messageObj): if not messageObj: return if not WS_MESSAGE_TYPE in messageObj: ProviderObserver.log( 'message without "{}" received from {}'.format( WS_MESSAGE_TYPE, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) return if not WS_DATA in messageObj: ProviderObserver.log( 'message without "{}" received from {}'.format( WS_DATA, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) return messageType = messageObj[WS_MESSAGE_TYPE] data = messageObj[WS_DATA] if messageType == WS_MESSAGE_TYPE_LIBRARY_CHANGED: self._ProcessMessageLibraryChanged(data) elif messageType == WS_MESSAGE_TYPE_USER_DATA_CHANGED: self._ProcessMessageUserDataChanged(data) elif messageType in (WS_MESSAGE_TYPE_SERVER_SHUTTING_DOWN, WS_MESSAGE_TYPE_SERVER_RESTARTING): self._ProcessMessageServer(messageType, data) else: ProviderObserver.log( 'ignoring "{}" message from {}'.format( messageType, mediaProvider2str(self._mediaProvider)), xbmc.LOGDEBUG) def _ProcessMessageLibraryChanged(self, data): ProviderObserver.log( 'processing library changed message from {}...'.format( mediaProvider2str(self._mediaProvider))) itemsAdded = data[WS_LIBRARY_CHANGED_ITEMS_ADDED] itemsUpdated = data[WS_LIBRARY_CHANGED_ITEMS_UPDATED] itemsRemoved = data[WS_LIBRARY_CHANGED_ITEMS_REMOVED] changedLibraryItems = [] # process all newly added items changedLibraryItems.extend( ProviderObserver._ProcessChangedItems( itemsAdded, xbmcmediaimport.MediaImportChangesetTypeAdded)) # process all updated items changedLibraryItems.extend( ProviderObserver._ProcessChangedItems( itemsUpdated, xbmcmediaimport.MediaImportChangesetTypeChanged)) # process all removed items changedLibraryItems.extend( ProviderObserver._ProcessChangedItems( itemsRemoved, xbmcmediaimport.MediaImportChangesetTypeRemoved)) # map the changed items to their media import changedItems = [] for (changesetType, itemId) in changedLibraryItems: item = None if changesetType == xbmcmediaimport.MediaImportChangesetTypeAdded or \ changesetType == xbmcmediaimport.MediaImportChangesetTypeChanged: # get all details for the added / changed item item = self._GetItemDetails(itemId) if not item: ProviderObserver.log( 'failed to get details for changed item with id "{}" from {}' .format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue else: # find the removed item in the list of imported items importedItems = xbmcmediaimport.getImportedItemsByProvider( self._mediaProvider) matchingItems = [ importedItem for importedItem in importedItems if kodi.Api.getEmbyItemIdFromItem(importedItem) == itemId ] if not matchingItems: ProviderObserver.log( 'failed to find removed item with id "{}" from {}'. format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue if len(matchingItems) > 1: ProviderObserver.log( 'multiple imported items for item with id "{}" from {} found => only removing the first one' .format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) item = matchingItems[0] if not item: ProviderObserver.log( 'failed to process changed item with id "{}" from {}'. format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue changedItems.append((changesetType, item, itemId)) self._ChangeItems(changedItems) @staticmethod def _ProcessChangedItems(items, changesetType): if not isinstance(items, list): return [] return [(changesetType, item) for item in items if isinstance(item, string_types) and item] def _ProcessMessageUserDataChanged(self, data): ProviderObserver.log( 'processing userdata changed message from {}...'.format( mediaProvider2str(self._mediaProvider))) userDataList = data[WS_USER_DATA_CHANGED_USER_DATA_LIST] changedItems = [] for userDataItem in userDataList: if not WS_USER_DATA_CHANGED_USER_DATA_ITEM_ID in userDataItem: continue itemId = userDataItem[WS_USER_DATA_CHANGED_USER_DATA_ITEM_ID] if not itemId or not isinstance(itemId, string_types): continue item = self._GetItemDetails(itemId) if not item: ProviderObserver.log( 'failed to get details for changed item with id "{}" from {}' .format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue changedItems.append( (xbmcmediaimport.MediaImportChangesetTypeChanged, item, itemId)) self._ChangeItems(changedItems) def _ProcessMessageServer(self, messageType, data): if not self._settings.getBool( SETTING_PROVIDER_INTERFACE_SHOW_SERVER_MESSAGES): return if messageType == WS_MESSAGE_TYPE_SERVER_SHUTTING_DOWN: message = 32051 elif messageType == WS_MESSAGE_TYPE_SERVER_RESTARTING: message = 32052 else: return xbmcgui.Dialog().notification( 'Emby Media Importer', localise(message).format(self._mediaProvider.getFriendlyName()), self._mediaProvider.getIconUrl()) def _ChangeItems(self, changedItems): # map the changed items to their media import changedItemsMap = {} for (changesetType, item, itemId) in changedItems: if not item: continue # find a matching import for the changed item mediaImport = self._FindImportForItem(item) if not mediaImport: ProviderObserver.log( 'failed to determine media import for changed item with id "{}" from {}' .format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue if mediaImport not in changedItemsMap: changedItemsMap[mediaImport] = [] changedItemsMap[mediaImport].append((changesetType, item)) # finally pass the changed items grouped by their media import to Kodi for (mediaImport, changedItems) in changedItemsMap.items(): if xbmcmediaimport.changeImportedItems(mediaImport, changedItems): ProviderObserver.log( 'changed {} imported items for media import {} from {}'. format(len(changedItems), mediaImport2str(mediaImport), mediaProvider2str(self._mediaProvider))) else: ProviderObserver.log( 'failed to change {} imported items for media import {} from {}' .format(len(changedItems), mediaImport2str(mediaImport), mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) def _GetItemDetails(self, itemId): # retrieve all details of the item itemObj = Library.GetItem(self._server, itemId) if not itemObj: ProviderObserver.log( 'cannot retrieve details of updated item with id "{}" from {}'. format(itemId, mediaProvider2str(self._mediaProvider)), xbmc.LOGERROR) return None return kodi.Api.toFileItem( self._server, itemObj, allowDirectPlay=self._settings.getBool( SETTING_PROVIDER_PLAYBACK_ALLOW_DIRECT_PLAY)) def _FindImportForItem(self, item): videoInfoTag = item.getVideoInfoTag() if not videoInfoTag: return None itemMediaType = videoInfoTag.getMediaType() matchingImports = [ mediaImport for mediaImport in self._imports if itemMediaType in mediaImport.getMediaTypes() ] if not matchingImports: return None return matchingImports[0] def _StartAction(self, mediaProvider): if not mediaProvider: raise RuntimeError('invalid mediaProvider') # if we are already connected check if something important changed in the media provider if self._connected: if kodi.Api.compareMediaProviders(self._mediaProvider, mediaProvider): # update the media provider and settings anyway self._mediaProvider = mediaProvider self._settings = self._mediaProvider.prepareSettings() return True self._StopAction(restart=True) self._mediaProvider = mediaProvider self._settings = self._mediaProvider.prepareSettings() if not self._settings: raise RuntimeError('cannot prepare media provider settings') try: # create emby server instance self._server = Server(self._mediaProvider) # authenticate with the Emby server authenticated = self._server.Authenticate(force=True) except: authenticated = False if not authenticated: ProviderObserver.log( 'failed to authenticate with {}'.format( mediaProvider2str(self._mediaProvider)), xbmc.LOGERROR) self._Reset() return False # analyze the media provider's URL urlParts = urlparse(self._mediaProvider.getBasePath()) # determine the proper scheme (ws:// or wss://) and whether or not to verify the HTTPS certificate websocketScheme = 'wss' if urlParts.scheme == 'https' else 'ws' # put the urL back together url = urlunparse( urlParts._replace(scheme=websocketScheme, path='embywebsocket')) url = Url.addOptions( url, { URL_QUERY_API_KEY: self._server.AccessToken(), URL_QUERY_DEVICE_ID: self._server.DeviceId() }) # create the websocket self._websocket = websocket.WebSocket() # connect the websocket try: self._websocket.connect(url) except Exception as err: ProviderObserver.log( 'failed to connect to {} using a websocket. {}'.format( url, err), xbmc.LOGERROR) self._Reset() return False # reduce the timeout self._websocket.settimeout(1.0) ProviderObserver.log( 'successfully connected to {} to observe media imports'.format( mediaProvider2str(self._mediaProvider))) self._connected = True return True def _StopAction(self, restart=False): if not self._connected: return if not restart: ProviderObserver.log( 'stopped observing media imports from {}'.format( mediaProvider2str(self._mediaProvider))) self._websocket.close() self._Reset() def _Reset(self): self._connected = False self._server = None self._mediaProvider = None @staticmethod def log(message, level=xbmc.LOGINFO): log('[observer] {}'.format(message), level)
def updateOnProvider(handle, options): # retrieve the media import mediaImport = xbmcmediaimport.getImport(handle) if not mediaImport: log('cannot retrieve media import', xbmc.LOGERROR) return # retrieve the media provider mediaProvider = mediaImport.getProvider() if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # prepare and get the media import settings importSettings = mediaImport.prepareSettings() if not importSettings: log('cannot prepare media import settings', xbmc.LOGERROR) return item = xbmcmediaimport.getUpdatedItem(handle) if not item: log('cannot retrieve updated item', xbmc.LOGERROR) return log('updating "{}" ({}) on {}...'.format(item.getLabel(), item.getPath(), mediaProvider2str(mediaProvider))) itemVideoInfoTag = item.getVideoInfoTag() if not itemVideoInfoTag: log('updated item is not a video item', xbmc.LOGERROR) return # determine the item's identifier itemId = kodi.Api.getEmbyItemIdFromVideoInfoTag(itemVideoInfoTag) if not itemId: log('cannot determine the identifier of the updated item: "{}"'.format(itemVideoInfoTag.getPath()), xbmc.LOGERROR) return # prepare the media provider settings if not mediaProvider.prepareSettings(): log('cannot prepare media provider settings', xbmc.LOGERROR) return # create an Emby server instance embyServer = Server(mediaProvider) if not embyServer.Authenticate(): log('failed to authenticate on media provider {}'.format(mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return # retrieve all details of the item itemObj = Library.GetItem(embyServer, itemId) if not itemObj: log('cannot retrieve details of updated item with id {}'.format(itemId), xbmc.LOGERROR) return if not emby.constants.PROPERTY_ITEM_USER_DATA in itemObj: log('cannot update item with id {} because it has no userdata'.format(itemId), xbmc.LOGERROR) return updateItemPlayed = False updatePlaybackPosition = False # retrieve playback states from the updated item playcount = itemVideoInfoTag.getPlayCount() watched = playcount > 0 lastPlayed = itemVideoInfoTag.getLastPlayed() # retrieve playback position from the updated item playbackPositionInSeconds = max(0.0, float(item.getProperty('resumetime'))) playbackPositionInTicks = kodi.Api.secondsToTicks(playbackPositionInSeconds) userDataObj = itemObj[emby.constants.PROPERTY_ITEM_USER_DATA] # check and update playcout if necessary if emby.constants.PROPERTY_ITEM_USER_DATA_PLAY_COUNT in userDataObj: # retrieve playcount from the original item itemPlayed = userDataObj[emby.constants.PROPERTY_ITEM_USER_DATA_PLAY_COUNT] > 0 if watched != itemPlayed: updateItemPlayed = True # check and update playback position if necessary if emby.constants.PROPERTY_ITEM_USER_DATA_PLAYBACK_POSITION_TICKS in userDataObj: # retrieve playback position from the original item itemPlaybackPositionInTicks = userDataObj[emby.constants.PROPERTY_ITEM_USER_DATA_PLAYBACK_POSITION_TICKS] if playbackPositionInTicks != itemPlaybackPositionInTicks: updatePlaybackPosition = True # nothing to do if no playback related properties have been changed if not updateItemPlayed and not updatePlaybackPosition: log('no playback related properties of "{}" ({}) have changed => nothing to update on {}'.format(item.getLabel(), item.getPath(), mediaProvider2str(mediaProvider))) return log('updating playback related properties of "{}" ({}) on {}...'.format(item.getLabel(), item.getPath(), mediaProvider2str(mediaProvider))) if not UserData.Update(embyServer, itemId, updateItemPlayed, updatePlaybackPosition, watched, playcount, lastPlayed, playbackPositionInTicks): log('updating playback related properties of "{}" ({}) on {} failed'.format(item.getLabel(), item.getPath(), mediaProvider2str(mediaProvider)), xbmc.LOGERROR) xbmcmediaimport.finishUpdateOnProvider(handle)
def execImport(handle, options): if not 'path' in options: log('cannot execute "import" without path', xbmc.LOGERROR) return # parse all necessary options mediaTypes = mediaTypesFromOptions(options) if not mediaTypes: log('cannot execute "import" without media types', xbmc.LOGERROR) return # retrieve the media import mediaImport = xbmcmediaimport.getImport(handle) if not mediaImport: log('cannot retrieve media import', xbmc.LOGERROR) return # prepare and get the media import settings importSettings = mediaImport.prepareSettings() if not importSettings: log('cannot prepare media import settings', xbmc.LOGERROR) return # retrieve the media provider mediaProvider = mediaImport.getProvider() if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return log('importing {} items from {}...'.format(mediaTypes, mediaProvider2str(mediaProvider))) # prepare the media provider settings mediaProviderSettings = mediaProvider.prepareSettings() if not mediaProviderSettings: log('cannot prepare media provider settings', xbmc.LOGERROR) return # create an Emby server instance embyServer = Server(mediaProvider) if not embyServer.Authenticate(): log('failed to authenticate on media provider {}'.format(mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return # build the base URL to retrieve items baseUrl = embyServer.BuildUserUrl(emby.constants.URL_ITEMS) baseUrlOptions = { 'Recursive': 'true', 'Fields': ','.join(EMBY_ITEM_FIELDS), 'ExcludeLocationTypes': 'Virtual,Offline', 'Limit': ITEM_REQUEST_LIMIT } baseUrl = Url.addOptions(baseUrl, baseUrlOptions) # get all (matching) library views selectedViews = getLibraryViewsFromSettings(importSettings) views = getMatchingLibraryViews(embyServer, mediaTypes, selectedViews) if not views: log('cannot retrieve items without any library views', xbmc.LOGERROR) return # determine whether Direct Play is allowed allowDirectPlay = mediaProviderSettings.getBool(emby.constants.SETTING_PROVIDER_PLAYBACK_ALLOW_DIRECT_PLAY) # determine whether to import collections importCollections = importSettings.getBool(emby.constants.SETTING_IMPORT_IMPORT_COLLECTIONS) # loop over all media types to be imported progress = 0 progressTotal = len(mediaTypes) for mediaType in mediaTypes: if xbmcmediaimport.shouldCancel(handle, progress, progressTotal): return progress += 1 if mediaType == xbmcmediaimport.MediaTypeVideoCollection and not importCollections: log('importing {} items from {} is disabled'.format(mediaType, mediaProvider2str(mediaProvider)), xbmc.LOGDEBUG) continue log('importing {} items from {}...'.format(mediaType, mediaProvider2str(mediaProvider))) mappedMediaType = kodi.Api.getEmbyMediaType(mediaType) if not mappedMediaType: log('cannot import unsupported media type "{}"'.format(mediaType), xbmc.LOGERROR) continue (_, embyMediaType, localizedMediaType) = mappedMediaType xbmcmediaimport.setProgressStatus(handle, __addon__.getLocalizedString(32001).format(__addon__.getLocalizedString(localizedMediaType))) urlOptions = { 'IncludeItemTypes': embyMediaType } url = Url.addOptions(baseUrl, urlOptions) boxsetUrlOptions = { 'IncludeItemTypes': kodi.EMBY_MEDIATYPE_BOXSET } boxsetUrl = Url.addOptions(baseUrl, boxsetUrlOptions) items = [] boxsets = {} # handle library views for view in views: log('importing {} items from "{}" view from {}...'.format(mediaType, view.name, mediaProvider2str(mediaProvider))) items.extend(importItems(handle, embyServer, url, mediaType, view.id, embyMediaType=embyMediaType, viewName=view.name, allowDirectPlay=allowDirectPlay)) if importCollections and items and mediaType == xbmcmediaimport.MediaTypeMovie: # retrieve all BoxSets / collections matching the current media type boxsetObjs = importItems(handle, embyServer, boxsetUrl, mediaType, view.id, raw=True, allowDirectPlay=allowDirectPlay) for boxsetObj in boxsetObjs: if not emby.constants.PROPERTY_ITEM_ID in boxsetObj or not emby.constants.PROPERTY_ITEM_NAME in boxsetObj: continue boxsetId = boxsetObj[emby.constants.PROPERTY_ITEM_ID] boxsetName = boxsetObj[emby.constants.PROPERTY_ITEM_NAME] boxsets[boxsetId] = boxsetName # handle BoxSets / collections if importCollections and items: for (boxsetId, boxsetName) in iteritems(boxsets): # get all items belonging to the BoxSet boxsetItems = importItems(handle, embyServer, url, mediaType, boxsetId, embyMediaType=embyMediaType, viewName=boxsetName, allowDirectPlay=allowDirectPlay) for boxsetItem in boxsetItems: # find the matching retrieved item for (index, item) in enumerate(items): if boxsetItem.getPath() == item.getPath(): # set the BoxSet / collection kodi.Api.setCollection(item, boxsetName) items[index] = item log('{} {} items imported from {}'.format(len(items), mediaType, mediaProvider2str(mediaProvider))) if items: xbmcmediaimport.addImportItems(handle, items, mediaType) xbmcmediaimport.finishImport(handle)
class Player(xbmc.Player): def __init__(self, progressInterval=None): super(xbmc.Player, self).__init__() self._lock = threading.Lock() self._progressInterval = progressInterval or 10 self._lastProgressReport = None self._providers = {} self._file = None self._item = None self._itemId = None self._mediaProvider = None self._server = None self._playSessionId = None self._paused = False self._playMethod = None self._lastPlaybackPosition = None def AddProvider(self, mediaProvider): if not mediaProvider: raise ValueError('invalid mediaProvider') with self._lock: self._providers[mediaProvider.getIdentifier()] = mediaProvider Player.log('{} added'.format(mediaProvider2str(mediaProvider))) def RemoveProvider(self, mediaProvider): if not mediaProvider: raise ValueError('invalid mediaProvider') with self._lock: del self._providers[mediaProvider.getIdentifier()] Player.log('{} removed'.format(mediaProvider2str(mediaProvider))) def Process(self): with self._lock: if not self._lastProgressReport: return # adhere to the configured progress interval if (time.time() - self._lastProgressReport) < self._progressInterval: return self._reportPlaybackProgress() def onPlayBackStarted(self): with self._lock: self._reset() try: self._file = self.getPlayingFile() except RuntimeError: pass def onAVStarted(self): with self._lock: self._startPlayback() def onPlayBackSeek(self, time, seekOffset): with self._lock: if self._reportPlaybackProgress(): Player.log('playback seek for "{}" ({}) on {} reported'.format( self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) def onPlayBackSeekChapter(self, chapter): with self._lock: if not self._item: return if self._reportPlaybackProgress(): Player.log( 'playback seek chapter for "{}" ({}) on {} reported'. format(self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) def onPlayBackPaused(self): with self._lock: self._paused = True if self._reportPlaybackProgress(): Player.log( 'playback paused for "{}" ({}) on {} reported'.format( self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) def onPlayBackResumed(self): with self._lock: self._paused = False if self._reportPlaybackProgress(): Player.log( 'playback resumed for "{}" ({}) on {} reported'.format( self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) def onPlayBackStopped(self): with self._lock: self._stopPlayback() def onPlayBackEnded(self): with self._lock: self._stopPlayback() def onPlayBackError(self): with self._lock: self._stopPlayback(failed=True) def _reset(self): self._file = None self._item = None self._itemId = None self._mediaProvider = None self._server = None self._playSessionId = None self._paused = False self._playMethod = None self._lastPlaybackPosition = None def _startPlayback(self): if not self._file: return if not self.isPlayingVideo(): return self._item = self.getPlayingItem() if not self._item: return # check if the item has been imported from a media provider mediaProviderId = self._item.getMediaProviderId() if not mediaProviderId: return if not mediaProviderId in self._providers: Player.log('currently playing item {} ({}) has been imported from an unknown media provider {}' \ .format(self._item.getLabel(), self._file, mediaProviderId), xbmc.LOGWARNING) return self._mediaProvider = self._providers[mediaProviderId] videoInfoTag = self.getVideoInfoTag() if not videoInfoTag: return self._itemId = kodi.Api.getEmbyItemIdFromVideoInfoTag(videoInfoTag) if not self._itemId: return settings = self._mediaProvider.prepareSettings() if not settings: Player.log('failed to load settings for {} ({}) playing from {}' \ .format(self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) self._reset() return # determine the play method if Server.IsDirectStreamUrl(self._mediaProvider, self._file): self._playMethod = PLAYING_PLAY_METHOD_DIRECT_STREAM else: self._playMethod = PLAYING_PLAY_METHOD_DIRECT_PLAY # setup and authenticate with the Emby server try: self._server = Server(self._mediaProvider) except: pass if not self._server or not self._server.Authenticate(): Player.log('cannot connect to media provider {} to report playback progress of "{}" ({})' \ .format(mediaProvider2str(self._mediaProvider), self._item.getLabel(), self._file), xbmc.LOGWARNING) self._reset() return # when using DirectStream add any external subtitles if self._playMethod == PLAYING_PLAY_METHOD_DIRECT_STREAM and \ settings.getBool(SETTING_PROVIDER_PLAYBACK_ENABLE_EXTERNAL_SUBTITLES): self._addExternalSubtitles() # generate a session identifier self._playSessionId = PlaybackCheckin.GenerateSessionId() # prepare the data of the API call data = self._preparePlayingData(stopped=False) # tell the Emby server that a library item is being played PlaybackCheckin.StartPlayback(self._server, data) self._lastProgressReport = time.time() Player.log('playback start for "{}" ({}) on {} reported'.format( self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) def _reportPlaybackProgress(self, event=PLAYING_PROGRESS_EVENT_TIME_UPDATE): if not self.isPlaying(): self._reset() if not self._item: return False data = self._preparePlayingData(stopped=False, event=event) PlaybackCheckin.PlaybackProgress(self._server, data) self._lastProgressReport = time.time() return True def _stopPlayback(self, failed=False): if not self._item: return data = self._preparePlayingData(stopped=True, failed=failed) PlaybackCheckin.StopPlayback(self._server, data) Player.log('playback stopped for "{}" ({}) on {} reported'.format( self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) self._reset() def _preparePlayingData(self, stopped=False, event=None, failed=False): try: # try to get the playback position from Kodi self._lastPlaybackPosition = self.getTime() except RuntimeError: # if that fails update it based on the time passed since the last progress report if not self._paused: Player.log( 'guessing the playback position for "{}" ({})'.format( self._item.getLabel(), self._file), xbmc.LOGDEBUG) self._lastPlaybackPosition += time.time( ) - self._lastProgressReport data = { 'ItemId': self._itemId, 'PlaySessionId': self._playSessionId, 'PlaylistIndex': 0, 'PlaylistLength': 1, 'PositionTicks': kodi.Api.secondsToTicks(self._lastPlaybackPosition), } if stopped: data.update({'Failed': failed}) else: data.update({ 'QueueableMediaTypes': 'Audio,Video', 'CanSeek': True, 'PlayMethod': self._playMethod, 'IsPaused': self._paused, }) try: data.update({ 'RunTimeTicks': kodi.Api.secondsToTicks(self.getTotalTime()), }) except RuntimeError: pass if event: data.update({'EventName': event}) return data def _addExternalSubtitles(self): if not self._item: return # get the item's details to look for external subtitles itemObj = Library.GetItem(self._server, self._itemId) if not itemObj: Player.log('cannot retrieve details of "{}" ({}) from media provider {}' \ .format(self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) return # extract the media source ID if not PROPERTY_ITEM_MEDIA_SOURCES in itemObj or not itemObj[ PROPERTY_ITEM_MEDIA_SOURCES]: Player.log('cannot add external subtitles for "{}" ({}) from media provider {} ' \ 'because it doesn\'t have a media source' \ .format(self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider)), xbmc.LOGDEBUG) return mediaSourceId = itemObj.get(PROPERTY_ITEM_MEDIA_SOURCES)[0].get( PROPERTY_ITEM_MEDIA_SOURCES_ID) # look for external subtitles for stream in itemObj.get(PROPERTY_ITEM_MEDIA_STREAMS): if stream.get(PROPERTY_ITEM_MEDIA_STREAM_TYPE ) != 'Subtitle' or not stream.get( PROPERTY_ITEM_MEDIA_STREAM_IS_EXTERNAL): continue # get the index of the subtitle index = stream.get(PROPERTY_ITEM_MEDIA_STREAM_INDEX) # determine the language and name name = stream.get( PROPERTY_ITEM_MEDIA_STREAM_DISPLAY_TITLE ) if PROPERTY_ITEM_MEDIA_STREAM_DISPLAY_TITLE in stream else '' language = stream.get( PROPERTY_ITEM_MEDIA_STREAM_LANGUAGE ) if PROPERTY_ITEM_MEDIA_STREAM_LANGUAGE in stream else '' # determine the stream URL if PROPERTY_ITEM_MEDIA_STREAM_DELIVERY_URL in stream and \ stream.get(PROPERTY_ITEM_MEDIA_STREAM_DELIVERY_URL).upper().startswith('/{}'.format(URL_VIDEOS)): url = self._server.BuildStreamDeliveryUrl( stream.get(PROPERTY_ITEM_MEDIA_STREAM_DELIVERY_URL)) else: url = self._server.BuildSubtitleStreamUrl( self._itemId, mediaSourceId, index, stream.get(PROPERTY_ITEM_MEDIA_STREAM_CODEC)) if not url: Player.log('cannot add external subtitle at index {} for "{}" ({}) from media provider {}' \ .format(index, self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider)), xbmc.LOGWARNING) continue self.addSubtitle(url, name, language, False) # TODO(Montellese): activate? Player.log('external subtitle "{}" [{}] at index {} added for "{}" ({}) from media provider {}' \ .format(name, language, index, self._item.getLabel(), self._file, mediaProvider2str(self._mediaProvider))) @staticmethod def log(message, level=xbmc.LOGINFO): log('[player] {}'.format(message), level)