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)
