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 try: embyServer = Server(mediaProvider) except: return # check if the chosen library views exist selectedViews = ImportSettings.GetLibraryViews(importSettings) matchingViews = getMatchingLibraryViews(embyServer, mediaImport.getMediaTypes(), selectedViews) xbmcmediaimport.setImportReady(handle, len(matchingViews) > 0)
def settingOptionsFillerViews(handle, _): # 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 try: embyServer = Server(mediaProvider) except: return libraryViews = getLibraryViews(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 linkEmbyConnect(handle, _): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # get the media provider settings providerSettings = mediaProvider.prepareSettings() if not providerSettings: return # make sure we have a valid device ID deviceId = providerSettings.getString(emby.constants.SETTING_PROVIDER_DEVICEID) if not deviceId: deviceId = Request.GenerateDeviceId() providerSettings.setString(emby.constants.SETTING_PROVIDER_DEVICEID, deviceId) embyConnect = linkToEmbyConnect(deviceId) if not embyConnect: return # make sure the configured Emby server is still accessible serverUrl = ProviderSettings.GetUrl(providerSettings) matchingServer = None serverId = Server.GetServerId(mediaProvider.getIdentifier()) # get all connected servers servers = EmbyConnect.GetServers(embyConnect.accessToken, embyConnect.userId) if not servers: log('no servers available for Emby Connect user id {}'.format(embyConnect.userId), xbmc.LOGWARNING) return for server in servers: if server.systemId == serverId: matchingServer = server break if not matchingServer: log('no Emby server matching {} found'.format(serverUrl), xbmc.LOGWARNING) xbmcgui.Dialog().ok(localise(32038), localise(32061)) return # change the settings providerSettings.setString(emby.constants.SETTING_PROVIDER_EMBY_CONNECT_USER_ID, embyConnect.userId) providerSettings.setString(emby.constants.SETTING_PROVIDER_EMBY_CONNECT_ACCESS_KEY, matchingServer.accessKey) success = False try: success = Server(mediaProvider).Authenticate(force=True) except: pass if success: xbmcgui.Dialog().ok(localise(32038), localise(32062)) log('successfully linked to Emby Connect server {} ({}) {}'.format(matchingServer.name, serverId, serverUrl)) else: xbmcgui.Dialog().ok(localise(32038), localise(32061)) log('failed to link to Emby Connect server {} ({}) {}'.format(matchingServer.name, serverId, serverUrl), xbmc.LOGWARNING)
def refreshMetadata(item, itemId, mediaProvider): # create an Emby server instance embyServer = Server(mediaProvider) # trigger a metadata refresh on the Emby server Library.RefreshItemMetadata(embyServer, itemId) log('[context/refresh] triggered metadata refresh for {} on {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider)))
def testAuthentication(handle, _): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return log('testing authentication with {}...'.format(mediaProvider2str(mediaProvider))) success = False try: success = Server(mediaProvider).Authenticate(force=True) except: pass line = 32018 if success: line = 32017 xbmcgui.Dialog().ok(mediaProvider.getFriendlyName(), localise(line))
def isProviderReady(handle, options): # 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 # check if authentication works with the current provider settings try: providerReady = Server(mediaProvider).Authenticate(force=True) except: providerReady = False xbmcmediaimport.setProviderReady(handle, providerReady)
def changeUrl(handle, _): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # get the media provider settings providerSettings = mediaProvider.prepareSettings() if not providerSettings: return urlCurrent = ProviderSettings.GetUrl(providerSettings) if not urlCurrent: log("cannot retrieve current URL from provider settings", xbmc.LOGERROR) return # ask the user for a new URL urlNew = xbmcgui.Dialog().input(localise(32045), urlCurrent) if not urlNew: return # store the new URL in the settings ProviderSettings.SetUrl(providerSettings, urlNew) # try to connect and authenticate with the new URL success = False try: success = Server(mediaProvider).Authenticate(force=True) except: pass dialog = xbmcgui.Dialog() title = mediaProvider.getFriendlyName() if success: dialog.ok(title, localise(32017)) else: # ask the user whether to change the URL anyway changeUrlAnyway = dialog.yesno(title, localise(32066)) if not changeUrlAnyway: # revert the settings to the previous / old URL ProviderSettings.SetUrl(providerSettings, urlCurrent)
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)
def synchronize(item, itemId, mediaProvider): # find the matching media import mediaImport = getMediaImport(mediaProvider, item) if not mediaImport: log( '[context/sync] cannot find the media import of {} from {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return # determine whether Direct Play is allowed mediaProviderSettings = mediaProvider.getSettings() allowDirectPlay = mediaProviderSettings.getBool( emby.constants.SETTING_PROVIDER_PLAYBACK_ALLOW_DIRECT_PLAY) # create an Emby server instance embyServer = Server(mediaProvider) # synchronize the active item syncedItem = synchronizeItem(item, itemId, mediaProvider, embyServer, allowDirectPlay=allowDirectPlay) if not syncedItem: return syncedItems = [(xbmcmediaimport.MediaImportChangesetTypeChanged, syncedItem)] if xbmcmediaimport.changeImportedItems(mediaImport, syncedItems): log('[context/sync] synchronized {} from {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider))) else: log( '[context/sync] failed to synchronize {} from {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider)), xbmc.LOGWARNING)
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 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)
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) # build the base URL to retrieve items baseUrl = embyServer.BuildUserUrl(emby.constants.URL_ITEMS) baseUrlOptions = { emby.constants.URL_QUERY_ITEMS_RECURSIVE: 'true', emby.constants.URL_QUERY_ITEMS_FIELDS: ','.join(EMBY_ITEM_FIELDS), emby.constants.URL_QUERY_ITEMS_EXCLUDE_LOCATION_TYPES: 'Virtual,Offline', emby.constants.URL_QUERY_ITEMS_LIMIT: ITEM_REQUEST_LIMIT } baseUrl = Url.addOptions(baseUrl, baseUrlOptions) # get all (matching) library views selectedViews = ImportSettings.GetLibraryViews(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) # determine the last sync time and whether we should perform a fast sync fastSync = False syncUrlOptions = {} # check if synchronization related settings have changed; if yes we have to perform a full synchronization if SynchronizationSettings.HaveChanged(mediaTypes, mediaProviderSettings, importSettings, save=True): log('forcing a full synchronization to import {} items from {} because some related settings have changed' \ .format(mediaTypes, mediaProvider2str(mediaProvider))) else: # check if we # have already performed a (full) synchronization before # should use the Kodi Companion Emby server plugin lastSync = mediaImport.getLastSynced() if lastSync and mediaProviderSettings.getBool( emby.constants. SETTING_PROVIDER_SYNCHRONIZATION_USE_KODI_COMPANION): if KodiCompanion.IsInstalled(embyServer): fastSync = True # convert the last sync datetime string to ISO 8601 lastSync = parser.parse(lastSync).astimezone(utc).isoformat( timespec='seconds') syncUrlOptions.update({ # only set MinDateLastSavedForUser because it already covers DateLastSaved, RatingLastModified # and PlaystateLastModified. Setting both MinDateLastSaved and MinDateLastSavedForUser will # cause issues, see https://emby.media/community/index.php?/topic/82258-retrieving-changeset-when-client-returns-online-mediaimport/ emby.constants.URL_QUERY_ITEMS_MIN_DATE_LAST_SAVED_FOR_USER: lastSync }) log('using fast synchronization to import {} items from {} with Kodi companion plugin' \ .format(mediaTypes, mediaProvider2str(mediaProvider)), xbmc.LOGDEBUG) # retrieving the sync queue from Kodi companion syncQueue = KodiCompanion.SyncQueue.GetItems( embyServer, lastSync) else: log('Kodi companion usage is enabled to import {} items from {} but the server plugin is not installed' \ .format(mediaTypes, mediaProvider2str(mediaProvider)), xbmc.LOGWARNING) # 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 = syncUrlOptions.copy() urlOptions.update( {emby.constants.URL_QUERY_ITEMS_INCLUDE_ITEM_TYPES: embyMediaType}) url = Url.addOptions(baseUrl, urlOptions) boxsetUrlOptions = { emby.constants.URL_QUERY_ITEMS_INCLUDE_ITEM_TYPES: 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 # in a fast sync we need to get the removed items from Kodi companion if fastSync: if items: log('{} changed {} items imported from {}'.format( len(items), mediaType, mediaProvider2str(mediaProvider))) # handle removed items through Kodi companion's sync queue if syncQueue.itemsRemoved: # retrieve all local items matching the current media type from the current import localItems = xbmcmediaimport.getImportedItems( handle, mediaType) # match the local items against the changed items removedItems, = kodi.Api.matchImportedItemIdsToLocalItems( localItems, syncQueue.itemsRemoved) # pylint: disable=unbalanced-tuple-unpacking # erase all removed items matching the current media type from the sync queue syncQueue.itemsRemoved = [ removedItem for removedItem in syncQueue.itemsRemoved if removedItem in removedItems ] if removedItems: log('{} previously imported {} items removed from {}'. format(len(removedItems), mediaType, mediaProvider2str(mediaProvider))) xbmcmediaimport.addImportItems( handle, removedItems, mediaType, xbmcmediaimport.MediaImportChangesetTypeRemoved) else: log('{} {} items imported from {}'.format( len(items), mediaType, mediaProvider2str(mediaProvider))) # pass the imported items back to Kodi if items: xbmcmediaimport.addImportItems(handle, items, mediaType) xbmcmediaimport.finishImport(handle, fastSync)
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 play(item, itemId, mediaProvider): if item.isFolder(): log( '[context/play] cannot play folder item {}'.format( listItem2str(item, itemId)), xbmc.LOGERROR) return # create an Emby server instance embyServer = Server(mediaProvider) # retrieve all details of the item itemObj = Library.GetItem(embyServer, itemId) if not itemObj: log( '[context/play] cannot retrieve the details of {} from {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return # cannot play folders if itemObj.get(emby.constants.PROPERTY_ITEM_IS_FOLDER): log( '[context/play] cannot play folder item {}'.format( listItem2str(item, itemId)), xbmc.LOGERROR) return playChoices = [] playChoicesUrl = [] # determine whether Direct Play is allowed mediaProviderSettings = mediaProvider.getSettings() allowDirectPlay = mediaProviderSettings.getBool( emby.constants.SETTING_PROVIDER_PLAYBACK_ALLOW_DIRECT_PLAY) # check if the item supports Direct Play and / or Direct Stream canDirectPlay = None directPlayUrl = None if allowDirectPlay: (canDirectPlay, directPlayUrl) = kodi.Api.getDirectPlayUrl(itemObj) if canDirectPlay and directPlayUrl: playChoices.append(localise(32101)) playChoicesUrl.append(directPlayUrl) (canDirectStream, directStreamUrl) = kodi.Api.getDirectStreamUrl(embyServer, itemId, itemObj) if canDirectStream: playChoices.append(localise(32102)) playChoicesUrl.append(directStreamUrl) # if there are no options something went wrong if not playChoices: log( '[context/play] cannot play {} from {}'.format( listItem2str(item, itemId), mediaProvider2str(mediaProvider)), xbmc.LOGERROR) return # ask the user how to play playChoice = Dialog().contextmenu(playChoices) if playChoice < 0 or playChoice >= len(playChoices): return playUrl = playChoicesUrl[playChoice] # play the item log('[context/play] playing {} using "{}" ({}) from {}'.format( listItem2str(item, itemId), playChoices[playChoice], playUrl, mediaProvider2str(mediaProvider))) # overwrite the dynamic path of the ListItem item.setDynamicPath(playUrl) xbmc.Player().play(playUrl, item)