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 settingOptionsFillerLibrarySections(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 server = Server(mediaProvider) if not server.Authenticate(): log('failed to connect to Plex Media Server for {}'.format(mediaProvider2str(mediaProvider)), xbmc.LOGWARNING) return plexServer = server.PlexServer() # get all library sections mediaTypes = mediaImport.getMediaTypes() librarySections = getLibrarySections(plexServer, mediaTypes) sections = [ (section['title'], section['key']) for section in librarySections ] # get the import's settings settings = mediaImport.getSettings() # pass the list of views back to Kodi settings.setStringOptions(plex.constants.SETTINGS_IMPORT_LIBRARY_SECTIONS, sections)
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 setting_options_filler_views(handle, _): # retrieve the media provider media_provider = xbmcmediaimport.getProvider(handle) if not media_provider: log("cannot retrieve media provider", xbmc.LOGERROR) return # retrieve the media import media_import = xbmcmediaimport.getImport(handle) if not media_import: log("cannot retrieve media import", xbmc.LOGERROR) return # prepare the media provider settings if not media_provider.prepareSettings(): log("cannot prepare media provider settings", xbmc.LOGERROR) return # TODO(stub): collect information and provide it as a list of options to the user # each option is a tuple(label, key) options = [("Foo", "foo"), ("Bar", "bar")] # get the import"s settings settings = media_import.getSettings() # pass the list of views back to Kodi settings.setStringOptions("stub.importviews", options)
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 is_import_ready(handle, _): # retrieve the media import media_import = xbmcmediaimport.getImport(handle) if not media_import: log("cannot retrieve media import", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # prepare and get the media import settings import_settings = media_import.prepareSettings() if not import_settings: log("cannot prepare media import settings", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # retrieve the media provider media_provider = xbmcmediaimport.getProvider(handle) if not media_provider: log("cannot retrieve media provider", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # prepare the media provider settings if not media_provider.prepareSettings(): log("cannot prepare media provider settings", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # TODO(stub): check if the configuration of the media import is valid / complete xbmcmediaimport.setImportReady(handle, True)
def loadProviderSettings(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return settings = mediaProvider.getSettings() if not settings: log('cannot retrieve media provider settings', xbmc.LOGERROR) return # make sure we have a device identifier if not settings.getString(emby.constants.SETTING_PROVIDER_DEVICEID): settings.setString(emby.constants.SETTING_PROVIDER_DEVICEID, str(uuid.uuid4())) settings.registerActionCallback( emby.constants.SETTING_PROVIDER_LINK_EMBY_CONNECT, 'linkembyconnect') settings.registerActionCallback( emby.constants.SETTING_PROVIDER_TEST_AUTHENTICATION, 'testauthentication') # register a setting options filler for the list of users settings.registerOptionsFillerCallback( emby.constants.SETTING_PROVIDER_USER, 'settingoptionsfillerusers') settings.setLoaded()
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 loadProviderSettings(handle: int, _options: dict): """Load and save settings from media provider at handle ID, register some callbacks in the settings :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, Unused :type _options: dict """ # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log("cannot retrieve media provider", xbmc.LOGERROR) return settings = mediaProvider.getSettings() if not settings: log("cannot retrieve media provider settings", xbmc.LOGERROR) return settings.registerActionCallback( plex.constants.SETTINGS_PROVIDER_LINK_MYPLEX_ACCOUNT, 'linkmyplexaccount') settings.registerActionCallback( plex.constants.SETTINGS_PROVIDER_TEST_CONNECTION, 'testconnection') settings.setLoaded()
def isProviderReady(handle: int, _options: dict): """Validate that the provider from handle ID exists, can be connected to, and that stored authentication works :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, Unused :type _options: dict """ # 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 providerReady = False try: providerReady = Server(mediaProvider).Authenticate() except: pass xbmcmediaimport.setProviderReady(handle, providerReady)
def lookupProvider(handle: int, _options: dict): """Find provider from handle ID, authenticate to it, and set as active :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, unused :type _options: dict """ # 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 providerFound = False try: providerFound = Server(mediaProvider).Authenticate() except: pass xbmcmediaimport.setProviderFound(handle, providerFound)
def testConnection(handle: int, _options: dict): """Test connection to the user provided PMS and display results to user :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, unused :type _options: dict """ # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return success = False try: success = Server(mediaProvider).Authenticate() except: pass title = mediaProvider.getFriendlyName() line = 32019 if success: line = 32018 xbmcgui.Dialog().ok(title, localize(line))
def test_authentication(handle, _): # retrieve the media provider media_provider = xbmcmediaimport.getProvider(handle) if not media_provider: log("cannot retrieve media provider", xbmc.LOGERROR) return log(f"testing authentication with {provider2str(media_provider)}...")
def linkMyPlexAccount(handle: int, _options: dict): """Have user sign into MyPlex account, find servers on the account, and save authenticatino details for the server :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, unused :type _options: dict """ # 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 plexAccount = linkToMyPlexAccount() if not plexAccount: return username = plexAccount.username if not username: log('no valid username available for the linked MyPlex account', xbmc.LOGWARNING) return # make sure the configured Plex Media Server is still accessible serverUrl = mediaProvider.getBasePath() matchingServer = None serverId = getServerId(mediaProvider.getIdentifier()) # get all connected server resources serverResources = getServerResources(plexAccount) for server in serverResources: if server.clientIdentifier == serverId: matchingServer = server break if not matchingServer: log(f"no Plex Media Server matching {serverUrl} found", xbmc.LOGWARNING) xbmcgui.Dialog().ok(localize(32015), localize(32058)) return xbmcgui.Dialog().ok(localize(32015), localize(32059, username)) # change the settings providerSettings.setString(plex.constants.SETTINGS_PROVIDER_USERNAME, username) providerSettings.setString(plex.constants.SETTINGS_PROVIDER_TOKEN, matchingServer.accessToken)
def isImportReady(handle: int, _options: dict): """Validate that MediaImport at handle ID and associated provider are ready :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, Unused :type _options: dict """ # retrieve the media import mediaImport = xbmcmediaimport.getImport(handle) if not mediaImport: log("cannot retrieve media import", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # prepare and get the media import settings importSettings = mediaImport.prepareSettings() if not importSettings: log("cannot prepare media import settings", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log("cannot retrieve media provider", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return # prepare the media provider settings if not mediaProvider.prepareSettings(): log("cannot prepare media provider settings", xbmc.LOGERROR) xbmcmediaimport.setImportReady(handle, False) return try: server = Server(mediaProvider) except: pass importReady = False # check if authentication works with the current provider settings if server.Authenticate(): # check if the chosen library sections exist selectedLibrarySections = getLibrarySectionsFromSettings(importSettings) matchingLibrarySections = getMatchingLibrarySections( server.PlexServer(), mediaImport.getMediaTypes(), selectedLibrarySections ) importReady = len(matchingLibrarySections) > 0 xbmcmediaimport.setImportReady(handle, importReady)
def changeUrl(handle: int, _options: dict): """Change the URL of PMS :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, unused :type _options: dict """ # 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: log("cannot prepare provider settings", xbmc.LOGERROR) 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(localize(32068), 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() except: pass dialog = xbmcgui.Dialog() title = mediaProvider.getFriendlyName() if success: dialog.ok(title, localize(32018)) else: # ask the user whether to change the URL anyway changeUrlAnyway = dialog.yesno(title, localize(32069)) if not changeUrlAnyway: # revert the settings to the previous / old URL ProviderSettings.SetUrl(providerSettings, urlCurrent)
def lookup_provider(handle, _): # retrieve the media provider media_provider = xbmcmediaimport.getProvider(handle) if not media_provider: log("cannot retrieve media provider", xbmc.LOGERROR) return settings = media_provider.prepareSettings() if not settings: log("cannot prepare media provider settings", xbmc.LOGERROR) return # TODO(stub): check if the media provider is active xbmcmediaimport.setProviderFound(handle, True)
def loadProviderSettings(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return settings = mediaProvider.getSettings() if not settings: log('cannot retrieve media provider settings', xbmc.LOGERROR) return settings.registerActionCallback(plex.constants.SETTINGS_PROVIDER_LINK_MYPLEX_ACCOUNT, 'linkmyplexaccount') settings.registerActionCallback(plex.constants.SETTINGS_PROVIDER_TEST_CONNECTION, 'testconnection') settings.setLoaded()
def settingOptionsFillerUsers(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return # get the provider's settings settings = mediaProvider.getSettings() users = [ (__addon__.getLocalizedString(32015), emby.constants.SETTING_PROVIDER_USER_OPTION_MANUAL) ] publicUsers = User.GetPublicUsers(mediaProvider.getBasePath(), deviceId=settings.getString(emby.constants.SETTING_PROVIDER_DEVICEID)) users.extend([ (user.name, user.id) for user in publicUsers ]) # pass the list of users back to Kodi settings.setStringOptions(emby.constants.SETTING_PROVIDER_USER, users)
def lookupProvider(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return basePath = mediaProvider.getBasePath() providerFound = False try: if emby.api.server.Server.GetInfo(basePath): providerFound = True except: pass xbmcmediaimport.setProviderFound(handle, providerFound)
def settingOptionsFillerLibrarySections(handle: int, _options: dict): """Find and set the library sections setting from Plex matching a mediaImport's media type :param handle: Handle id from input :type handle: int :param _options: Options/parameters passed in with the call, Unused :type _options: dict """ # 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 server = Server(mediaProvider) if not server.Authenticate(): log( f"failed to connect to Plex Media Server for {mediaProvider2str(mediaProvider)}", xbmc.LOGWARNING) return plexServer = server.PlexServer() # get all library sections mediaTypes = mediaImport.getMediaTypes() librarySections = getLibrarySections(plexServer, mediaTypes) sections = [(section['title'], section['key']) for section in librarySections] # get the import's settings settings = mediaImport.getSettings() # pass the list of views back to Kodi settings.setStringOptions(plex.constants.SETTINGS_IMPORT_LIBRARY_SECTIONS, sections)
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 resetDeviceId(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 deviceId = Request.GenerateDeviceId() log('created a new device identifier for {}: {}'.format(mediaProvider2str(mediaProvider), deviceId)) providerSettings.setString(emby.constants.SETTING_PROVIDER_DEVICEID, deviceId) xbmcgui.Dialog().ok(mediaProvider.getFriendlyName(), localise(32063))
def testConnection(handle, options): # retrieve the media provider mediaProvider = xbmcmediaimport.getProvider(handle) if not mediaProvider: log('cannot retrieve media provider', xbmc.LOGERROR) return success = False try: success = Server(mediaProvider).Authenticate() except: pass title = mediaProvider.getFriendlyName() line = 32019 if success: line = 32018 xbmcgui.Dialog().ok(title, localise(line))
def linkMyPlexAccount(handle, options): # 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 plexAccount = linkToMyPlexAccount() if not plexAccount: return username = plexAccount.username if not username: log('no valid username available for the linked MyPlex account', xbmc.LOGWARNING) return # make sure the configured Plex Media Server is still accessible serverUrl = mediaProvider.getBasePath() matchingServer = None serverId = getServerId(mediaProvider.getIdentifier()) # get all connected server resources serverResources = getServerResources(plexAccount) for server in serverResources: if server.clientIdentifier == serverId: matchingServer = server break if not matchingServer: log('no Plex Media Server matching {} found'.format(serverUrl), xbmc.LOGWARNING) xbmcgui.Dialog().ok(localise(32015), localise(32058)) return xbmcgui.Dialog().ok(localise(32015), localise(32059).format(username)) # change the settings providerSettings.setString(plex.constants.SETTINGS_PROVIDER_USERNAME, username) providerSettings.setString(plex.constants.SETTINGS_PROVIDER_TOKEN, matchingServer.accessToken)
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 load_provider_settings(handle, _): # retrieve the media provider media_provider = xbmcmediaimport.getProvider(handle) if not media_provider: log("cannot retrieve media provider", xbmc.LOGERROR) return settings = media_provider.getSettings() if not settings: log("cannot retrieve media provider settings", xbmc.LOGERROR) return # TODO(stub): register action callbacks settings.registerActionCallback("stub.testauthentication", "testauthentication") # TODO(stub): register setting options fillers settings.setLoaded()
def lookupProvider(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 providerFound = False try: providerFound = Server(mediaProvider).Authenticate() except: pass xbmcmediaimport.setProviderFound(handle, providerFound)
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)