def _addServer(self, server: PlexServer):
"""Add a discovered PMS server as a MediaProvider to the Kodi mediaimport system
:param server: The discovered PlexServer to add into the Kodi mediaimport system
:type server: :class:`PlexServer`
"""
registerServer = False
# check if the server is already known
if server.id not in self._servers:
self._servers[server.id] = server
registerServer = True
else:
# check if the server has already been registered or if some of its properties have changed
if (not self._servers[server.id].registered
or self._servers[server.id].name != server.name
or self._servers[server.id].address != server.address):
self._servers[server.id] = server
registerServer = True
else:
# simply update the server's last seen property
self._servers[server.id].lastseen = server.lastseen
# if the server doesn't need to be registered there's nothing else to do
if not registerServer:
return
providerId = Server.BuildProviderId(server.id)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(
providerId, server.name, providerIconUrl,
plex.constants.SUPPORTED_MEDIA_TYPES)
# store local authentication in settings
providerSettings = provider.prepareSettings()
if not providerSettings:
return
ProviderSettings.SetUrl(providerSettings, server.address)
ProviderSettings.SetAuthenticationMethod(providerSettings, \
plex.constants.SETTINGS_PROVIDER_AUTHENTICATION_OPTION_LOCAL)
providerSettings.save()
if xbmcmediaimport.addAndActivateProvider(provider):
self._servers[server.id].registered = True
log(
f"Plex Media Server {mediaProvider2str(provider)} successfully added and activated",
xbmc.LOGINFO)
else:
self._servers[server.id].registered = False
log(
f"failed to add and/or activate Plex Media Server {mediaProvider2str(provider)}",
xbmc.LOGINFO)
def _addServer(self, server):
registerServer = False
# check if the server is already known
if server.id not in self._servers:
self._servers[server.id] = server
registerServer = True
else:
# check if the server has already been registered or if some of its properties have changed
if not self._servers[server.id].registered or self._servers[server.id].name != server.name or \
self._servers[server.id].address != server.address:
self._servers[server.id] = server
registerServer = True
else:
# simply update the server's last seen property
self._servers[server.id].lastseen = server.lastseen
# if the server doesn't need to be registered there's nothing else to do
if not registerServer:
return
providerId = Server.BuildProviderId(server.id)
providerIconUrl = getIcon()
mediaProvider = xbmcmediaimport.MediaProvider(
providerId, server.name, providerIconUrl,
emby.constants.SUPPORTED_MEDIA_TYPES)
settings = mediaProvider.prepareSettings()
if not settings:
log('cannot prepare media provider settings', xbmc.LOGERROR)
return
ProviderSettings.SetUrl(settings, server.address)
if xbmcmediaimport.addAndActivateProvider(mediaProvider):
self._servers[server.id].registered = True
log('Emby server "{}" ({}) successfully added and activated'.
format(server.name, server.id))
else:
self._servers[server.id].registered = False
log('failed to add and/or activate Emby server "{}" ({})'.format(
server.name, server.id))
def discoverProviderLocally(handle: int, _options: dict) -> xbmcmediaimport.MediaProvider:
"""Set up a Plex server provider from user-provided URL
:param handle: Handle id from input
:type handle: int
:param _options: Options/parameters passed in with the call, unused
:type _options: dict
:return: Fully setup and populated mediaProvider object for the PMS
:rtype: xbmcmediaimport.MediaProvider
"""
dialog = xbmcgui.Dialog()
baseUrl = dialog.input(localize(32051))
if not baseUrl:
return None
plexServer = PlexServer(baseUrl, timeout=plex.constants.REQUEST_TIMEOUT)
if not plexServer:
return None
providerId = Server.BuildProviderId(plexServer.machineIdentifier)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(
identifier=providerId,
friendlyName=plexServer.friendlyName,
iconUrl=providerIconUrl,
mediaTypes=plex.constants.SUPPORTED_MEDIA_TYPES,
handle=handle
)
# store local authentication in settings
providerSettings = provider.prepareSettings()
if not providerSettings:
return None
ProviderSettings.SetUrl(providerSettings, baseUrl)
ProviderSettings.SetAuthenticationMethod(providerSettings, \
plex.constants.SETTINGS_PROVIDER_AUTHENTICATION_OPTION_LOCAL)
providerSettings.save()
return provider
def discoverProviderLocally(handle, options): # pylint: disable=unused-argument
baseUrl = xbmcgui.Dialog().input(localise(32050), 'http://')
if not baseUrl:
return None
log('trying to discover an Emby server at {}...'.format(baseUrl))
try:
serverInfo = emby.api.server.Server.GetInfo(baseUrl)
if not serverInfo:
return None
except:
return None
providerId = Server.BuildProviderId(serverInfo.id)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(providerId, serverInfo.name, providerIconUrl,
emby.constants.SUPPORTED_MEDIA_TYPES)
settings = provider.prepareSettings()
if not settings:
log('cannot prepare media provider settings', xbmc.LOGERROR)
return
ProviderSettings.SetUrl(settings, baseUrl)
# store local authentication in settings
providerSettings = provider.prepareSettings()
if not providerSettings:
return None
providerSettings.setString(emby.constants.SETTING_PROVIDER_AUTHENTICATION,
emby.constants.SETTING_PROVIDER_AUTHENTICATION_OPTION_LOCAL)
providerSettings.save()
log('Local Emby server {} successfully discovered at {}'.format(mediaProvider2str(provider), baseUrl))
return provider
def discoverProviderWithEmbyConnect(handle, options): # pylint: disable=unused-argument
deviceId = Request.GenerateDeviceId()
embyConnect = linkToEmbyConnect(deviceId)
if not embyConnect:
return None
dialog = xbmcgui.Dialog()
# 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 None
if len(servers) == 1:
server = servers[0]
else:
# ask the user which server to use
serverChoices = [server.name for server in servers]
serverChoice = dialog.select(localise(32057), serverChoices)
if serverChoice < 0 or serverChoice >= len(serverChoices):
return None
server = servers[serverChoice]
if not server:
return None
urls = []
if server.localUrl:
# ask the user whether to use a local or remote connection
isLocal = dialog.yesno(localise(32058), localise(32059).format(server.name))
if isLocal:
urls.append(server.localUrl)
if server.remoteUrl:
urls.append(server.remoteUrl)
baseUrl = None
# find a working connection / base URL
for url in urls:
try:
_ = emby.api.server.Server.GetInfo(url)
except:
log('failed to connect to "{}" at {}'.format(server.name, url), xbmc.LOGDEBUG)
continue
baseUrl = url
break
if not baseUrl:
dialog.ok(localise(32058), localise(32060).format(server.name))
log('failed to connect to Emby server "{}" with Emby Connect user ID {}'
.format(server.name, embyConnect.userId), xbmc.LOGWARNING)
return None
providerId = Server.BuildProviderId(server.systemId)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(providerId, server.name, providerIconUrl,
emby.constants.SUPPORTED_MEDIA_TYPES)
providerSettings = provider.prepareSettings()
if not providerSettings:
log('cannot prepare media provider settings', xbmc.LOGERROR)
return
ProviderSettings.SetUrl(providerSettings, baseUrl)
# store Emby connect authentication in settings
providerSettings.setString(emby.constants.SETTING_PROVIDER_AUTHENTICATION,
emby.constants.SETTING_PROVIDER_AUTHENTICATION_OPTION_EMBY_CONNECT)
providerSettings.setString(emby.constants.SETTING_PROVIDER_EMBY_CONNECT_USER_ID, embyConnect.userId)
providerSettings.setString(emby.constants.SETTING_PROVIDER_EMBY_CONNECT_ACCESS_KEY, server.accessKey)
providerSettings.setString(emby.constants.SETTING_PROVIDER_DEVICEID, deviceId)
providerSettings.save()
log('Emby Connect server {} successfully discovered at {}'.format(mediaProvider2str(provider), baseUrl))
return provider
def discoverProviderWithMyPlex(handle: int, _options: dict) -> xbmcmediaimport.MediaProvider:
"""
Prompts user to sign into their Plex account using the MyPlex pin link
Finds a list of all servers connected to the account and prompts user to pick one
Prompt for a local discovery if no servers found within their Plex account
Setup and store the Plex server as a MediaProvider and store MyPlex auth information
:param handle: Handle id from input
:type handle: int
:param _options: Options/parameters passed in with the call, unused
:type _options: dict
:return: Fully configured and authenticated Plex media provider
:rtype: :class:`xbmcmediaimport.MediaProvider`
"""
plexAccount = linkToMyPlexAccount()
if not plexAccount:
return None
username = plexAccount.username
if not username:
log("no valid username available for the linked MyPlex account", xbmc.LOGWARNING)
return None
dialog = xbmcgui.Dialog()
# get all connected server resources
serverResources = getServerResources(plexAccount)
if not serverResources:
log(f"no servers available for MyPlex account {username}", xbmc.LOGWARNING)
return None
if len(serverResources) == 1:
server = serverResources[0]
else:
# ask the user which server to use
servers = [resource.name for resource in serverResources]
serversChoice = dialog.select(localize(32055), servers)
if serversChoice < 0 or serversChoice >= len(servers):
return None
server = serverResources[serversChoice]
if not server:
return None
if not server.connections:
# try to connect to the server
plexServer = server.connect(timeout=plex.constants.REQUEST_TIMEOUT)
if not plexServer:
log(f"failed to connect to the Plex Media Server '{server.name}'", xbmc.LOGWARNING)
return None
baseUrl = plexServer.url('', includeToken=False)
else:
isLocal = False
localConnections = [connection for connection in server.connections if connection.local]
remoteConnections = [
connection for connection in server.connections if not connection.local and not connection.relay
]
remoteRelayConnections = [
connection for connection in server.connections if not connection.local and connection.relay
]
if localConnections:
# ask the user whether to use a local or remote connection
isLocal = dialog.yesno(localize(32056), localize(32057, server.name))
urls = []
if isLocal:
urls.append((localConnections[0].httpuri, False))
else:
urls.extend([(conn.uri, False) for conn in remoteConnections])
urls.extend([(conn.uri, True) for conn in remoteRelayConnections])
urls.extend([(conn.uri, False) for conn in localConnections])
baseUrl = None
connectViaRelay = True
# find a working connection / base URL
for (url, isRelay) in urls:
try:
# don't try to connect via relay if the user has already declined it before
if isRelay and not connectViaRelay:
log(f"ignoring relay connection to the Plex Media Server '{server.name}' at {url}", xbmc.LOGDEBUG)
continue
# try to connect to the server
_ = PlexServer(baseurl=url, token=server.accessToken, timeout=plex.constants.REQUEST_TIMEOUT)
# if this is a relay ask the user if using it is ok
if isRelay:
connectViaRelay = dialog.yesno(localize(32056), localize(32061, server.name))
if not connectViaRelay:
log(
f"ignoring relay connection to the Plex Media Server '{server.name}' at {url}",
xbmc.LOGDEBUG
)
continue
baseUrl = url
break
except:
log(f"failed to connect to '{server.name}' at {url}", xbmc.LOGDEBUG)
continue
if not baseUrl:
dialog.ok(localize(32056), localize(32060, server.name))
log(
f"failed to connect to the Plex Media Server '{server.name}' for MyPlex account {username}",
xbmc.LOGWARNING
)
return None
if not baseUrl:
log(
f"failed to find the URL to access the Plex Media Server '{server.name}' for MyPlex account {username}",
xbmc.LOGWARNING
)
return None
log(
f"successfully connected to Plex Media Server '{server.name}' for MyPlex account {username} at {baseUrl}",
xbmc.LOGINFO
)
providerId = plex.server.Server.BuildProviderId(server.clientIdentifier)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(
providerId,
server.name,
providerIconUrl,
plex.constants.SUPPORTED_MEDIA_TYPES,
handle=handle
)
# store MyPlex account details and token in settings
providerSettings = provider.prepareSettings()
if not providerSettings:
return None
ProviderSettings.SetUrl(providerSettings, baseUrl)
ProviderSettings.SetAuthenticationMethod(providerSettings, \
plex.constants.SETTINGS_PROVIDER_AUTHENTICATION_OPTION_MYPLEX)
ProviderSettings.SetUsername(providerSettings, username)
ProviderSettings.SetAccessToken(providerSettings, server.accessToken)
providerSettings.save()
return provider