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