Ejemplo n.º 1
0
    def __init__(self):
    
        client_info = clientinfo.ClientInfo()
        self.version = client_info.get_version()
        self.device_id = client_info.get_device_id()
        
        # user agent string, used for OS and Kodi version identification
        kodi_ver = xbmc.getInfoLabel("System.BuildVersion")
        if(not kodi_ver):
            kodi_ver = "na"
        kodi_ver = kodi_ver.strip()
        if(kodi_ver.find(" ") > 0):
            kodi_ver = kodi_ver[0:kodi_ver.find(" ")]
        self.userAgent = "Kodi/" + kodi_ver + " (" + self.getUserAgentOS() + ")"
        
        # Use set user name
        self.user_name = settings('username') or settings('connectUsername') or 'None'
        
        # use md5 for client and user for analytics
        self.device_id = hashlib.md5(self.device_id).hexdigest()
        self.user_name = hashlib.md5(self.user_name).hexdigest()
        
        # resolution
        self.screen_mode = xbmc.getInfoLabel("System.ScreenMode")
        self.screen_height = xbmc.getInfoLabel("System.ScreenHeight")
        self.screen_width = xbmc.getInfoLabel("System.ScreenWidth")

        self.lang = xbmc.getInfoLabel("System.Language")
Ejemplo n.º 2
0
    def _startup(self):
        
        serverId = settings('serverId')
        if(serverId != None):
            serverId = hashlib.md5(serverId).hexdigest()
        
        ga = GoogleAnalytics()
        ga.sendEventData("Application", "Startup", serverId)
        try:
            ga.sendEventData("Version", "OS", platform.platform())
            ga.sendEventData("Version", "Python", platform.python_version())
        except Exception:
            pass

        # Start up events
        self.warn_auth = True

        username = self.userclient_thread.get_username()
        if settings('connectMsg') == "true" and username:
            # Get additional users
            add_users = settings('additionalUsers')
            if add_users:
                add_users = ", "+", ".join(add_users.split(','))

            dialog(type_="notification",
                   heading="{emby}",
                   message=("%s %s%s"
                            % (lang(33000), username.decode('utf-8'),
                               add_users.decode('utf-8'))),
                   icon="{emby}",
                   time=2000,
                   sound=False)
        return True
Ejemplo n.º 3
0
    def saveLastSync(self):

        # Save last sync time
        overlap = 2

        try: # datetime fails when used more than once, TypeError
            if self.isFastSync:
                result = self.doUtils("{server}/emby/Emby.Kodi.SyncQueue/GetServerDateTime?format=json")
                server_time = result['ServerDateTime']
                server_time = utils.convertDate(server_time)
            else:
                raise Exception("Fast sync server plugin is not enabled.")

        except Exception as e:
            # If the server plugin is not installed or an error happened.
            log.debug("An exception occurred: %s" % e)
            time_now = datetime.utcnow()-timedelta(minutes=overlap)
            lastSync = time_now.strftime('%Y-%m-%dT%H:%M:%SZ')
            log.info("New sync time: client time -%s min: %s" % (overlap, lastSync))

        else:
            lastSync = (server_time - timedelta(minutes=overlap)).strftime('%Y-%m-%dT%H:%M:%SZ')
            log.info("New sync time: server time -%s min: %s" % (overlap, lastSync))

        finally:
            settings('LastIncrementalSync', value=lastSync)
Ejemplo n.º 4
0
    def isDirectStream(self):

        item = self.item

        if (utils.settings('transcodeH265') == "true" and
                item['MediaSources'][0]['Name'].startswith(("1080P/HEVC","1080P/H265"))):
            # Avoid H265 1080p
            self.logMsg("Option to transcode 1080P/H265 enabled.", 1)
            return False

        elif (utils.settings('transcode720H265') == "true" and
                item['MediaSources'][0]['Name'].startswith(("720P/HEVC","720P/H265"))):
            # Avoid H265 720p
            self.logMsg("Option to transcode 720P/H265 enabled.", 1)
            return False

        # Requirement: BitRate, supported encoding
        canDirectStream = item['MediaSources'][0]['SupportsDirectStream']
        # Make sure the server supports it
        if not canDirectStream:
            return False

        # Verify the bitrate
        if not self.isNetworkSufficient():
            self.logMsg("The network speed is insufficient to direct stream file.", 1)
            return False

        return True
Ejemplo n.º 5
0
 def onSettingsChanged(self):
     """
     Monitor the PKC settings for changes made by the user
     """
     # settings: window-variable
     items = {
         'logLevel': 'plex_logLevel',
         'enableContext': 'plex_context',
         'plex_restricteduser': '******',
         'dbSyncIndicator': 'dbSyncIndicator',
         'remapSMB': 'remapSMB',
         'replaceSMB': 'replaceSMB',
         'force_transcode_pix': 'plex_force_transcode_pix',
         'fetch_pms_item_number': 'fetch_pms_item_number'
     }
     # Path replacement
     for typus in REMAP_TYPE_FROM_PLEXTYPE.values():
         for arg in ('Org', 'New'):
             key = 'remapSMB%s%s' % (typus, arg)
             items[key] = key
     # Reset the window variables from the settings variables
     for settings_value, window_value in items.iteritems():
         if window(window_value) != settings(settings_value):
             log.debug('PKC settings changed: %s is now %s'
                       % (settings_value, settings(settings_value)))
             window(window_value, value=settings(settings_value))
             if settings_value == 'fetch_pms_item_number':
                 log.info('Requesting playlist/nodes refresh')
                 window('plex_runLibScan', value="views")
Ejemplo n.º 6
0
    def CheckPMS(self):
        """
        Check the PMS that was set in file settings.
        Will return False if we need to reconnect, because:
            PMS could not be reached (no matter the authorization)
            machineIdentifier did not match

        Will also set the PMS machineIdentifier in the file settings if it was
        not set before
        """
        answer = True
        chk = self.plx.CheckConnection(self.server,
                                       verifySSL=False)
        if chk is False:
            self.logMsg('Could not reach PMS %s' % self.server, -1)
            answer = False
        if answer is True and not self.serverid:
            self.logMsg('No PMS machineIdentifier found for %s. Trying to '
                        'get the PMS unique ID' % self.server, 1)
            self.serverid = GetMachineIdentifier(self.server)
            if self.serverid is None:
                self.logMsg('Could not retrieve machineIdentifier', -1)
                answer = False
            else:
                utils.settings('plex_machineIdentifier', value=self.serverid)
        elif answer is True:
            tempServerid = GetMachineIdentifier(self.server)
            if tempServerid != self.serverid:
                self.logMsg('The current PMS %s was expected to have a '
                            'unique machineIdentifier of %s. But we got '
                            '%s. Pick a new server to be sure'
                            % (self.server, self.serverid, tempServerid), 1)
                answer = False
        return answer
Ejemplo n.º 7
0
def getDeviceId(reset=False):
    """
    Returns a unique Plex client id "X-Plex-Client-Identifier" from Kodi
    settings file.
    Also loads Kodi window property 'plex_client_Id'

    If id does not exist, create one and save in Kodi settings file.
    """
    if reset is True:
        window('plex_client_Id', clear=True)
        settings('plex_client_Id', value="")

    clientId = window('plex_client_Id')
    if clientId:
        return clientId

    clientId = settings('plex_client_Id')
    # Because Kodi appears to cache file settings!!
    if clientId != "" and reset is False:
        window('plex_client_Id', value=clientId)
        log.warn("Unique device Id plex_client_Id loaded: %s" % clientId)
        return clientId

    log.warn("Generating a new deviceid.")
    from uuid import uuid4
    clientId = str(uuid4())
    settings('plex_client_Id', value=clientId)
    window('plex_client_Id', value=clientId)
    log.warn("Unique device Id plex_client_Id loaded: %s" % clientId)
    return clientId
Ejemplo n.º 8
0
 def mustTranscode(self):
     """
     Returns True if we need to transcode because
         - codec is in h265
         - 10bit video codec
         - HEVC codec
     if the corresponding file settings are set to 'true'
     """
     videoCodec = self.API.getVideoCodec()
     log.info("videoCodec: %s" % videoCodec)
     if (settings('transcodeHi10P') == 'true' and
             videoCodec['bitDepth'] == '10'):
         log.info('Option to transcode 10bit video content enabled.')
         return True
     codec = videoCodec['videocodec']
     if (settings('transcodeHEVC') == 'true' and codec == 'hevc'):
         log.info('Option to transcode HEVC video codec enabled.')
         return True
     if codec is None:
         # e.g. trailers. Avoids TypeError with "'h265' in codec"
         log.info('No codec from PMS, not transcoding.')
         return False
     try:
         resolution = int(videoCodec['resolution'])
     except (TypeError, ValueError):
         log.info('No video resolution from PMS, not transcoding.')
         return False
     if 'h265' in codec:
         if resolution >= self.getH265():
             log.info("Option to transcode h265 enabled. Resolution of "
                      "the media: %s, transcoding limit resolution: %s"
                      % (str(resolution), str(self.getH265())))
             return True
     return False
Ejemplo n.º 9
0
    def startSync(self):
        # Run at start up - optional to use the server plugin
        if utils.settings('SyncInstallRunDone') == "true":
            
            # Validate views
            self.refreshViews()
            completed = False
            # Verify if server plugin is installed.
            if utils.settings('serverSync') == "true":
                # Try to use fast start up
                url = "{server}/emby/Plugins?format=json"
                result = self.doUtils.downloadUrl(url)

                for plugin in result:
                    if plugin['Name'] == "Emby.Kodi Sync Queue":
                        self.logMsg("Found server plugin.", 2)
                        completed = self.fastSync()
            
            if not completed:
                # Fast sync failed or server plugin is not found
                completed = self.fullSync(manualrun=True)
        else:
            # Install sync is not completed
            completed = self.fullSync()
        
        return completed
Ejemplo n.º 10
0
def getRecentEpisodes(viewid, mediatype, tagname, limit):
    count = 0
    # if the addon is called with recentepisodes parameter,
    # we return the recentepisodes list of the given tagname
    xbmcplugin.setContent(HANDLE, 'episodes')
    appendShowTitle = settings('RecentTvAppendShow') == 'true'
    appendSxxExx = settings('RecentTvAppendSeason') == 'true'
    # First we get a list of all the TV shows - filtered by tag
    params = {
        'sort': {'order': "descending", 'method': "dateadded"},
        'filter': {'operator': "is", 'field': "tag", 'value': "%s" % tagname},
    }
    result = JSONRPC('VideoLibrary.GetTVShows').execute(params)
    # If we found any, find the oldest unwatched show for each one.
    try:
        items = result['result'][mediatype]
    except (KeyError, TypeError):
        # No items, empty folder
        xbmcplugin.endOfDirectory(handle=HANDLE)
        return

    allshowsIds = set()
    for item in items:
        allshowsIds.add(item['tvshowid'])
    params = {
        'sort': {'order': "descending", 'method': "dateadded"},
        'properties': ["title", "playcount", "season", "episode", "showtitle",
            "plot", "file", "rating", "resume", "tvshowid", "art",
            "streamdetails", "firstaired", "runtime", "cast", "writer",
            "dateadded", "lastplayed"],
        "limits": {"end": limit}
    }
    if settings('TVShowWatched') == 'false':
        params['filter'] = {
            'operator': "lessthan",
            'field': "playcount",
            'value': "1"
        }
    result = JSONRPC('VideoLibrary.GetEpisodes').execute(params)
    try:
        episodes = result['result']['episodes']
    except (KeyError, TypeError):
        pass
    else:
        for episode in episodes:
            if episode['tvshowid'] in allshowsIds:
                li = createListItem(episode,
                                    appendShowTitle=appendShowTitle,
                                    appendSxxExx=appendSxxExx)
                xbmcplugin.addDirectoryItem(
                            handle=HANDLE,
                            url=episode['file'],
                            listitem=li)
                count += 1

            if count == limit:
                break

    xbmcplugin.endOfDirectory(handle=HANDLE)
Ejemplo n.º 11
0
    def get_token(cls):

        ###$ Begin migration $###
        if settings('token') == "":
            settings('token', value=settings('accessToken'))
            log.info("token migration completed")
        ###$ End migration $###

        return settings('token') or None
Ejemplo n.º 12
0
 def setUp(self):
     with utils.settings(server_ip):
         if firewall.has_chain():
             with utils.settings(server_ip):
                 iptables(firewall.flush_chain)
         else:
             with utils.settings(server_ip):
                 iptables(firewall.make_chain)
                 iptables(firewall.jump_to_chain())
Ejemplo n.º 13
0
 def getDeviceName(self):
     if settings('deviceNameOpt') == "false":
         # Use Kodi's deviceName
         deviceName = tryDecode(xbmc.getInfoLabel('System.FriendlyName'))
     else:
         deviceName = settings('deviceName')
         deviceName = deviceName.replace("\"", "_")
         deviceName = deviceName.replace("/", "_")
     return deviceName
Ejemplo n.º 14
0
    def loadCurrUser(self, username, userId, usertoken, authenticated=False):
        log.debug('Loading current user')
        doUtils = self.doUtils

        self.currUserId = userId
        self.currToken = usertoken
        self.currServer = self.getServer()
        self.ssl = self.getSSLverify()
        self.sslcert = self.getSSL()

        if authenticated is False:
            log.debug('Testing validity of current token')
            res = PlexAPI.PlexAPI().CheckConnection(self.currServer,
                                                    token=self.currToken,
                                                    verifySSL=self.ssl)
            if res is False:
                # PMS probably offline
                return False
            elif res == 401:
                log.error('Token is no longer valid')
                return 401
            elif res >= 400:
                log.error('Answer from PMS is not as expected. Retrying')
                return False

        # Set to windows property
        window('currUserId', value=userId)
        window('plex_username', value=username)
        # This is the token for the current PMS (might also be '')
        window('pms_token', value=self.currToken)
        # This is the token for plex.tv for the current user
        # Is only '' if user is not signed in to plex.tv
        window('plex_token', value=settings('plexToken'))
        window('plex_restricteduser', value=settings('plex_restricteduser'))
        window('pms_server', value=self.currServer)
        window('plex_machineIdentifier', value=self.machineIdentifier)
        window('plex_servername', value=self.servername)
        window('plex_authenticated', value='true')

        window('useDirectPaths', value='true'
               if settings('useDirectPaths') == "1" else 'false')
        window('plex_force_transcode_pix', value='true'
               if settings('force_transcode_pix') == "1" else 'false')

        # Start DownloadUtils session
        doUtils.startSession(reset=True)
        # self.getAdditionalUsers()
        # Set user preferences in settings
        self.currUser = username
        self.setUserPref()

        # Writing values to settings file
        settings('username', value=username)
        settings('userid', value=userId)
        settings('accessToken', value=usertoken)
        return True
Ejemplo n.º 15
0
    def getSSLverify(self):
        # Verify host certificate
        s_sslverify = settings('sslverify')
        if settings('altip') == "true":
            s_sslverify = settings('secondsslverify')

        if s_sslverify == "true":
            return True
        else:
            return False
Ejemplo n.º 16
0
    def getSSL(self):
        # Client side certificate
        s_cert = settings('sslcert')
        if settings('altip') == "true":
            s_cert = settings('secondsslcert')

        if s_cert == "None":
            return None
        else:
            return s_cert
Ejemplo n.º 17
0
    def getSSLverify(self):
        # Verify host certificate
        s_sslverify = utils.settings("sslverify")
        if utils.settings("altip") == "true":
            s_sslverify = utils.settings("secondsslverify")

        if s_sslverify == "true":
            return True
        else:
            return False
Ejemplo n.º 18
0
    def __init__(self):

        self.artwork = artwork.Artwork()
        self.emby = embyserver.Read_EmbyServer()
        self.do_url = downloadutils.DownloadUtils().downloadUrl
        self.should_stop = should_stop

        self.kodi_version = int(xbmc.getInfoLabel('System.BuildVersion')[:2])
        self.direct_path = settings('useDirectPaths') == "1"
        self.content_msg = settings('newContent') == "true"
Ejemplo n.º 19
0
    def getSSL(self):
        # Client side certificate
        s_cert = utils.settings("sslcert")
        if utils.settings("altip") == "true":
            s_cert = utils.settings("secondsslcert")

        if s_cert == "None":
            return None
        else:
            return s_cert
Ejemplo n.º 20
0
    def isDirectPlay(self):

        item = self.item

        # Requirement: Filesystem, Accessible path
        if utils.settings('playFromStream') == "true":
            # User forcing to play via HTTP
            self.logMsg("Can't direct play, play from HTTP enabled.", 1)
            return False

        if (utils.settings('transcodeH265') == "true" and 
                result['MediaSources'][0]['Name'].startswith("1080P/H265")):
            # Avoid H265 1080p
            self.logMsg("Option to transcode 1080P/H265 enabled.", 1)
            return False

        canDirectPlay = item['MediaSources'][0]['SupportsDirectPlay']
        # Make sure direct play is supported by the server
        if not canDirectPlay:
            self.logMsg("Can't direct play, server doesn't allow/support it.", 1)
            return False

        location = item['LocationType']
        if location == "FileSystem":
            # Verify the path
            if not self.fileExists():
                self.logMsg("Unable to direct play.")
                try:
                    count = int(utils.settings('failCount'))
                except ValueError:
                    count = 0
                self.logMsg("Direct play failed: %s times." % count, 1)

                if count < 2:
                    # Let the user know that direct play failed
                    utils.settings('failCount', value=str(count+1))
                    xbmcgui.Dialog().notification(
                                        heading="Emby server",
                                        message="Unable to direct play.",
                                        icon="special://home/addons/plugin.video.emby/icon.png",
                                        sound=False)
                elif utils.settings('playFromStream') != "true":
                    # Permanently set direct stream as true
                    utils.settings('playFromStream', value="true")
                    utils.settings('failCount', value="0")
                    xbmcgui.Dialog().notification(
                                        heading="Emby server",
                                        message=("Direct play failed 3 times. Enabled play "
                                                 "from HTTP in the add-on settings."),
                                        icon="special://home/addons/plugin.video.emby/icon.png",
                                        sound=False)
                return False

        return True
Ejemplo n.º 21
0
    def __init__(self):

        self.enable_texture_cache = settings('enableTextureCache') == "true"
        self.image_cache_limit = int(settings('imageCacheLimit')) * 5
        log.debug("image cache thread count: %s", self.image_cache_limit)

        if not self.xbmc_port and self.enable_texture_cache:
            self._set_webserver_details()

        self.user_id = window('emby_currUser')
        self.server = window('emby_server%s' % self.user_id)
Ejemplo n.º 22
0
    def get_ssl(cls):
        """
            Returns boolean value or path to certificate
            True: Verify ssl
            False: Don't verify connection
        """
        certificate = settings('sslcert')
        if certificate != "None":
            return certificate

        return True if settings('sslverify') == "true" else False
Ejemplo n.º 23
0
    def getDeviceName(self):

        if utils.settings('deviceNameOpt') == "false":
            # Use Kodi's deviceName
            deviceName = xbmc.getInfoLabel('System.FriendlyName').decode('utf-8')
        else:
            deviceName = utils.settings('deviceName')
            deviceName = deviceName.replace("\"", "_")
            deviceName = deviceName.replace("/", "_")

        return deviceName
Ejemplo n.º 24
0
    def __init__(self):

        self.enableTextureCache = utils.settings('enableTextureCache') == "true"
        self.imageCacheLimitThreads = int(utils.settings("imageCacheLimit"))
        self.imageCacheLimitThreads = int(self.imageCacheLimitThreads * 5);
        utils.logMsg("Using Image Cache Thread Count: " + str(self.imageCacheLimitThreads), 1)
        
        if not self.xbmc_port and self.enableTextureCache:
            self.setKodiWebServerDetails()

        self.userId = utils.window('currUserId')
        self.server = utils.window('pms_server')
Ejemplo n.º 25
0
 def getUsername(self):
     """
     Returns username as unicode
     """
     username = settings('username')
     if not username:
         log.debug("No username saved, trying to get Plex username")
         username = settings('plexLogin')
         if not username:
             log.debug("Also no Plex username found")
             return ""
     return username
Ejemplo n.º 26
0
    def onSettingsChanged(self):
        # Monitor emby settings
        current_log_level = settings('logLevel')
        if window('emby_logLevel') != current_log_level:
            # The log level changed, set new prop
            log.info("New log level: %s", current_log_level)
            window('emby_logLevel', value=current_log_level)

        current_context = "true" if settings('enableContext') == "true" else ""
        if window('emby_context') != current_context:
            log.info("New context setting: %s", current_context)
            window('emby_context', value=current_context)
Ejemplo n.º 27
0
    def _set_user_server(self):

        user = self.doutils.downloadUrl("{server}/emby/Users/{UserId}?format=json")
        settings('username', value=user['Name'])
        self._user = user

        if "PrimaryImageTag" in self._user:
            window('EmbyUserImage',
                   value=artwork.Artwork().get_user_artwork(self._user['Id'], 'Primary'))

        self._server = self.doutils.downloadUrl("{server}/emby/System/Configuration?format=json")
        settings('markPlayed', value=str(self._server['MaxResumePct']))
Ejemplo n.º 28
0
    def resetClient(self):

        log("Reset UserClient authentication.", 1)
        if self.currToken is not None:
            # In case of 401, removed saved token
            settings('accessToken', value="")
            window('emby_accessToken%s' % self.getUserId(), clear=True)
            self.currToken = None
            log("User token has been removed.", 1)

        self.auth = True
        self.currUser = None
Ejemplo n.º 29
0
    def setUserPref(self):

        doUtils = self.doUtils.downloadUrl

        result = doUtils("{server}/emby/Users/{UserId}?format=json")
        self.userSettings = result
        # Set user image for skin display
        if result.get('PrimaryImageTag'):
            window('EmbyUserImage', value=artwork.Artwork().getUserArtwork(result['Id'], 'Primary'))

        # Set resume point max
        result = doUtils("{server}/emby/System/Configuration?format=json")
        settings('markPlayed', value=str(result['MaxResumePct']))
Ejemplo n.º 30
0
    def fastSync(self):

        lastSync = settings('LastIncrementalSync')
        if not lastSync:
            lastSync = "2010-01-01T00:00:00Z"

        lastSyncTime = utils.convertDate(lastSync)
        log.info("Last sync run: %s" % lastSyncTime)

        # get server RetentionDateTime
        try:
            result = self.doUtils("{server}/emby/Emby.Kodi.SyncQueue/GetServerDateTime?format=json")
            retention_time = result['RetentionDateTime']
        except Exception as error:
            log.error(error)
            retention_time = "2010-01-01T00:00:00Z"

        retention_time = utils.convertDate(retention_time)
        log.info("RetentionDateTime: %s" % retention_time)

        # if last sync before retention time do a full sync
        if retention_time > lastSyncTime:
            log.info("Fast sync server retention insufficient, fall back to full sync")
            return False

        params = {'LastUpdateDT': lastSync}
        if settings('enableMusic') != "true":
            params['filter'] = "music"
        url = "{server}/emby/Emby.Kodi.SyncQueue/{UserId}/GetItems?format=json"

        try:
            result = self.doUtils(url, parameters=params)
            processlist = {

                'added': result['ItemsAdded'],
                'update': result['ItemsUpdated'],
                'userdata': result['UserDataChanged'],
                'remove': result['ItemsRemoved']
            }

        except Exception as error: # To be reviewed to only catch specific errors.
            log.error(error)
            log.error("Failed to retrieve latest updates using fast sync.")
            xbmcgui.Dialog().ok(lang(29999), lang(33095))
            return False

        else:
            log.info("Fast sync changes: %s" % result)
            for action in processlist:
                self.triage_items(action, processlist[action])
            return True
Ejemplo n.º 31
0
    def isDirectPlay(self):
        """
        Returns the path/playurl if successful, False otherwise
        """
        # True for e.g. plex.tv watch later
        if self.API.shouldStream() is True:
            self.logMsg("Plex item optimized for direct streaming", 1)
            return False

        # set to either 'Direct Stream=1' or 'Transcode=2'
        if utils.settings('playType') != "0":
            # User forcing to play via HTTP
            self.logMsg("User chose to not direct play", 1)
            return False

        if self.h265enabled():
            return False

        path = self.API.validatePlayurl(self.API.getFilePath(),
                                        self.API.getType(),
                                        forceCheck=True)
        if path is None:
            self.logMsg('Kodi cannot access file %s - no direct play' % path,
                        1)
            return False
        else:
            self.logMsg('Kodi can access file %s - direct playing' % path, 1)
            return path
Ejemplo n.º 32
0
def watchlater():
    """
    Listing for plex.tv Watch Later section (if signed in to plex.tv)
    """
    if window('plex_token') == '':
        log.error('No watch later - not signed in to plex.tv')
        return xbmcplugin.endOfDirectory(HANDLE, False)
    if window('plex_restricteduser') == 'true':
        log.error('No watch later - restricted user')
        return xbmcplugin.endOfDirectory(HANDLE, False)

    xml = downloadutils.DownloadUtils().downloadUrl(
        'https://plex.tv/pms/playlists/queue/all',
        authenticate=False,
        headerOptions={'X-Plex-Token': window('plex_token')})
    if xml in (None, 401):
        log.error('Could not download watch later list from plex.tv')
        return xbmcplugin.endOfDirectory(HANDLE, False)

    log.info('Displaying watch later plex.tv items')
    xbmcplugin.setContent(HANDLE, 'movies')
    for item in xml:
        __build_item(item)

    xbmcplugin.endOfDirectory(
        handle=HANDLE, cacheToDisc=settings('enableTextureCache') == 'true')
Ejemplo n.º 33
0
    def load_connect_servers(self):
        # Set connect servers
        if not settings('connectUsername'):
            return

        servers = self.connectmanager.get_connect_servers()
        added_servers = []
        for server in servers:
            if server['Id'] != settings('serverId'):
                # TODO: SSL setup
                self.doutils.add_server(server, False)
                added_servers.append(server['Id'])

        # Set properties
        log.info(added_servers)
        window('emby_servers.json', value=added_servers)
Ejemplo n.º 34
0
    def getPlayUrl(self):
        """
        Returns the playurl for the part
        (movie might consist of several files)

        playurl is in unicode!
        """
        self.api.mediastream_number()
        playurl = self.isDirectPlay()
        if playurl is not None:
            LOG.info("File is direct playing.")
            self.item.playmethod = 'DirectPlay'
        elif self.isDirectStream():
            LOG.info("File is direct streaming.")
            playurl = self.api.transcode_video_path('DirectStream')
            self.item.playmethod = 'DirectStream'
        else:
            LOG.info("File is transcoding.")
            playurl = self.api.transcode_video_path(
                'Transcode',
                quality={
                    'maxVideoBitrate': self.get_bitrate(),
                    'videoResolution': self.get_resolution(),
                    'videoQuality': '100',
                    'mediaBufferSize': int(settings('kodi_video_cache'))/1024,
                })
            self.item.playmethod = 'Transcode'
        LOG.info("The playurl is: %s", playurl)
        self.item.file = playurl
        return playurl
Ejemplo n.º 35
0
    def __init__(self, embycursor, kodicursor):

        self.embycursor = embycursor
        self.kodicursor = kodicursor

        self.emby = embyserver.Read_EmbyServer()
        self.music_enabled = settings('enableMusic') == "true"
Ejemplo n.º 36
0
    def isDirectStream(self):

        log = self.logMsg

        item = self.item

        videotrack = item['MediaSources'][0]['Name']
        transcodeH265 = utils.settings('transcodeH265')

        if transcodeH265 in ("1", "2", "3") and ("HEVC" in videotrack
                                                 or "H265" in videotrack):
            # Avoid H265/HEVC depending on the resolution
            resolution = int(videotrack.split("P", 1)[0])
            res = {'1': 480, '2': 720, '3': 1080}
            log(
                "Resolution is: %sP, transcode for resolution: %sP+" %
                (resolution, res[transcodeH265]), 1)
            if res[transcodeH265] <= resolution:
                return False

        # Requirement: BitRate, supported encoding
        canDirectStream = item['MediaSources'][0]['SupportsDirectStream']
        # Make sure the server supports it
        if not canDirectStream:
            return False

        # Verify the bitrate
        if not self.isNetworkSufficient():
            log("The network speed is insufficient to direct stream file.", 1)
            return False

        return True
Ejemplo n.º 37
0
def init_plex_playqueue(itemid,
                        librarySectionUUID,
                        mediatype='movie',
                        trailers=False):
    """
    Returns raw API metadata XML dump for a playlist with e.g. trailers.
   """
    url = "{server}/playQueues"
    args = {
        'type':
        mediatype,
        'uri': ('library://' + librarySectionUUID +
                '/item/%2Flibrary%2Fmetadata%2F' + itemid),
        'includeChapters':
        '1',
        'shuffle':
        '0',
        'repeat':
        '0'
    }
    if trailers is True:
        args['extrasPrefixCount'] = settings('trailerNumber')
    xml = downloadutils.DownloadUtils().downloadUrl(url + '?' +
                                                    urlencode(args),
                                                    action_type="POST")
    try:
        xml[0].tag
    except (IndexError, TypeError, AttributeError):
        log.error("Error retrieving metadata for %s" % url)
        return None
    return xml
Ejemplo n.º 38
0
 def __init__(self, data, labels, info):
     "Initialize a handler for making statistics on ML data"
     super().__init__(**settings(data=data, labels=labels, info=info))
     self.kneg, self.kpos = None, None
     self.neg, self.pos = None, None
     self.features = list()
     self.scores = list()
Ejemplo n.º 39
0
    def _rate_song(self):

        with DatabaseConn('music') as cursor_music:
            query = "SELECT rating FROM song WHERE idSong = ?"
            cursor_music.execute(query, (self.kodi_id, ))
            try:
                value = cursor_music.fetchone()[0]
                current_value = int(round(float(value), 0))
            except TypeError:
                pass
            else:
                new_value = dialog("numeric", 0, lang(30411),
                                   str(current_value))
                if new_value > -1:

                    new_value = int(new_value)
                    if new_value > 5:
                        new_value = 5

                    if settings('enableUpdateSongRating') == "true":
                        musicutils.updateRatingToFile(new_value,
                                                      self.api.get_file_path())

                    query = "UPDATE song SET rating = ? WHERE idSong = ?"
                    cursor_music.execute(query, (
                        new_value,
                        self.kodi_id,
                    ))
Ejemplo n.º 40
0
def check_migration():
    log.info('Checking whether we need to migrate something')
    last_migration = settings('last_migrated_PKC_version')
    if last_migration == v.ADDON_VERSION:
        log.info('Already migrated to PKC version %s' % v.ADDON_VERSION)
        return
    if not last_migration:
        log.info('Never migrated, so checking everything')
        last_migration = '1.0.0'

    if not compare_version(v.ADDON_VERSION, '1.8.2'):
        log.info('Migrating to version 1.8.1')
        # Set the new PKC theMovieDB key
        settings('themoviedbAPIKey', value='19c90103adb9e98f2172c6a6a3d85dc4')

    settings('last_migrated_PKC_version', value=v.ADDON_VERSION)
Ejemplo n.º 41
0
 def isDirectPlay(self):
     """
     Returns the path/playurl if we can direct play, None otherwise
     """
     # True for e.g. plex.tv watch later
     if self.api.should_stream() is True:
         LOG.info("Plex item optimized for direct streaming")
         return
     # Check whether we have a strm file that we need to throw at Kodi 1:1
     path = self.api.file_path()
     if path is not None and path.endswith('.strm'):
         LOG.info('.strm file detected')
         playurl = self.api.validate_playurl(path,
                                             self.api.plex_type(),
                                             force_check=True)
         return playurl
     # set to either 'Direct Stream=1' or 'Transcode=2'
     # and NOT to 'Direct Play=0'
     if settings('playType') != "0":
         # User forcing to play via HTTP
         LOG.info("User chose to not direct play")
         return
     if self.mustTranscode():
         return
     return self.api.validate_playurl(path,
                                     self.api.plex_type(),
                                     force_check=True)
Ejemplo n.º 42
0
    def getBitrate(self):

        # get the addon video quality
        bitrate = {

            '0': 664,
            '1': 996,
            '2': 1320,
            '3': 2000,
            '4': 3200,
            '5': 4700,
            '6': 6200,
            '7': 7700,
            '8': 9200,
            '9': 10700,
            '10': 12200,
            '11': 13700,
            '12': 15200,
            '13': 16700,
            '14': 18200,
            '15': 20000,
            '16': 40000,
            '17': 100000,
            '18': 1000000
        }

        # max bit rate supported by server (max signed 32bit integer)
        return bitrate.get(settings('videoBitrate'), 2147483)
Ejemplo n.º 43
0
def GetPlexPlaylist(itemid, librarySectionUUID, mediatype='movie'):
    """
    Returns raw API metadata XML dump for a playlist with e.g. trailers.
   """
    trailerNumber = settings('trailerNumber')
    if not trailerNumber:
        trailerNumber = '3'
    url = "{server}/playQueues"
    args = {
        'type':
        mediatype,
        'uri':
        'library://' + librarySectionUUID + '/item/%2Flibrary%2Fmetadata%2F' +
        itemid,
        'includeChapters':
        '1',
        'extrasPrefixCount':
        trailerNumber,
        'shuffle':
        '0',
        'repeat':
        '0'
    }
    xml = downloadutils.DownloadUtils().downloadUrl(url + '?' +
                                                    urlencode(args),
                                                    type="POST")
    try:
        xml[0].tag
    except (IndexError, TypeError, AttributeError):
        logMsg(title, "Error retrieving metadata for %s" % url, -1)
        return None
    return xml
Ejemplo n.º 44
0
    def setProperties(self, playurl, listitem):

        # Set all properties necessary for plugin path playback
        itemid = self.item['Id']
        itemtype = self.item['Type']

        embyitem = "emby_%s" % playurl
        window('%s.runtime' % embyitem,
               value=str(self.item.get('RunTimeTicks')))
        window('%s.type' % embyitem, value=itemtype)
        window('%s.itemid' % embyitem, value=itemid)

        if itemtype == "Episode":
            window('%s.refreshid' % embyitem, value=self.item.get('SeriesId'))
        else:
            window('%s.refreshid' % embyitem, value=itemid)

        # Append external subtitles to stream
        playmethod = window('%s.playmethod' % embyitem)
        # Only for direct stream
        if playmethod in (
                "DirectStream") and settings('enableExternalSubs') == "true":
            # Direct play automatically appends external
            subtitles = self.externalSubs(playurl)
            listitem.setSubtitles(subtitles)

        self.setArtwork(listitem)
Ejemplo n.º 45
0
    def _on_play_(self, data):
        # Set up report progress for emby playback
        try:
            if KODI >= 17:
                item = xbmc.Player().getVideoInfoTag()
                kodi_id = item.getDbId()
                item_type = item.getMediaType()
                log.info("kodi_id: %s item_type: %s", kodi_id, item_type)
            else:
                item = data['item']
                kodi_id = item['id']
                item_type = item['type']
                log.info("kodi_id: %s item_type: %s", kodi_id, item_type)
        except (KeyError, TypeError):
            log.info("Item is invalid for playstate update")
        else:
            if ((settings('useDirectPaths') == "1" and not item_type == "song")
                    or
                (item_type == "song" and settings('enableMusic') == "true")):
                # Set up properties for player
                item_id = self._get_item_id(kodi_id, item_type)
                if item_id:
                    url = "{server}/emby/Users/{UserId}/Items/%s?format=json" % item_id
                    result = self.download(url)
                    log.debug("Item: %s", result)

                    playurl = None
                    count = 0
                    while not playurl and count < 2:
                        try:
                            playurl = xbmc.Player().getPlayingFile()
                        except RuntimeError:
                            count += 1
                            xbmc.sleep(200)
                        else:
                            listitem = xbmcgui.ListItem()
                            playback = pbutils.PlaybackUtils(result)

                            if item_type == "song" and settings(
                                    'streamMusic') == "true":
                                window('emby_%s.playmethod' % playurl,
                                       value="DirectStream")
                            else:
                                window('emby_%s.playmethod' % playurl,
                                       value="DirectPlay")
                            # Set properties for player.py
                            playback.setProperties(playurl, listitem)
Ejemplo n.º 46
0
    def isDirectPlay(self):

        # Requirement: Filesystem, Accessible path
        if settings('playFromStream') == "true":
            # User forcing to play via HTTP
            log.info("Can't direct play, play from HTTP enabled.")
            return False

        videotrack = self.item['MediaSources'][0]['Name']
        transcodeH265 = settings('transcodeH265')
        videoprofiles = [
            x['Profile'] for x in self.item['MediaSources'][0]['MediaStreams']
            if 'Profile' in x
        ]
        transcodeHi10P = settings('transcodeHi10P')

        if transcodeHi10P == "true" and "H264" in videotrack and "High 10" in videoprofiles:
            return False

        if transcodeH265 in ("1", "2", "3") and ("HEVC" in videotrack
                                                 or "H265" in videotrack):
            # Avoid H265/HEVC depending on the resolution
            resolution = int(videotrack.split("P", 1)[0])
            res = {'1': 480, '2': 720, '3': 1080}
            log.info("Resolution is: %sP, transcode for resolution: %sP+" %
                     (resolution, res[transcodeH265]))
            if res[transcodeH265] <= resolution:
                return False

        canDirectPlay = self.item['MediaSources'][0]['SupportsDirectPlay']
        # Make sure direct play is supported by the server
        if not canDirectPlay:
            log.info("Can't direct play, server doesn't allow/support it.")
            return False

        location = self.item['LocationType']
        if location == "FileSystem":
            # Verify the path
            if not self.fileExists():
                log.info("Unable to direct play.")
                log.info(self.directPlay())
                xbmcgui.Dialog().ok(heading=lang(29999),
                                    line1=lang(33011),
                                    line2=(self.directPlay()))
                sys.exit()

        return True
Ejemplo n.º 47
0
    def run(self):
        log = self.logMsg
        # Currently not working due to missing SSL environment
        sslopt = {}
        if utils.settings('sslverify') == "false":
            sslopt["cert_reqs"] = ssl.CERT_NONE

        log("----===## Starting WebSocketClient ##===----", 0)

        threadStopped = self.threadStopped
        threadSuspended = self.threadSuspended
        while not threadStopped():
            # In the event the server goes offline
            while threadSuspended():
                # Set in service.py
                if self.ws is not None:
                    try:
                        self.ws.shutdown()
                    except:
                        pass
                    self.ws = None
                if threadStopped():
                    # Abort was requested while waiting. We should exit
                    log("##===---- WebSocketClient Stopped ----===##", 0)
                    return
                xbmc.sleep(1000)
            try:
                self.process(*self.receive(self.ws))
            except websocket.WebSocketTimeoutException:
                # No worries if read timed out
                pass
            except websocket.WebSocketConnectionClosedException:
                log("Connection closed, (re)connecting", 0)
                uri = self.getUri()
                try:
                    # Low timeout - let's us shut this thread down!
                    self.ws = websocket.create_connection(
                        uri, timeout=1, sslopt=sslopt, enable_multithread=True)
                except IOError:
                    log("Error connecting", 0)
                    self.ws = None
                    xbmc.sleep(1000)
                except websocket.WebSocketTimeoutException:
                    log("timeout while connecting, trying again", 0)
                    self.ws = None
                    xbmc.sleep(1000)
                except Exception as e:
                    log("Unknown exception encountered in connecting: %s" % e)
                    self.ws = None
                    xbmc.sleep(1000)
            except Exception as e:
                log("Unknown exception encountered: %s" % e)
                try:
                    self.ws.shutdown()
                except:
                    pass
                self.ws = None

        log("##===---- WebSocketClient Stopped ----===##", 0)
Ejemplo n.º 48
0
def getSettings():
    client = clientinfo.ClientInfo()
    options = {}
    title = 'PlexCompanion Settings'

    options['gdm_debug'] = settings('companionGDMDebugging')
    options['gdm_debug'] = True if options['gdm_debug'] == 'true' else False

    options['client_name'] = settings('deviceName')

    # XBMC web server options
    options['webserver_enabled'] = (getGUI('webserver') == "true")
    logMsg(title, 'Webserver is set to %s' % options['webserver_enabled'], 0)
    webserverport = getGUI('webserverport')
    try:
        webserverport = int(webserverport)
        logMsg(title, 'Using webserver port %s' % str(webserverport), 0)
    except:
        logMsg(
            title, 'No setting for webserver port found in guisettings.xml.'
            'Using default fallback port 8080', 0)
        webserverport = 8080
    options['port'] = webserverport

    options['user'] = getGUI('webserverusername')
    options['passwd'] = getGUI('webserverpassword')
    logMsg(
        title, 'Webserver username: %s, password: %s' %
        (options['user'], options['passwd']), 1)

    options['addonName'] = client.getAddonName()
    options['uuid'] = settings('plex_client_Id')
    options['platform'] = client.getPlatform()
    options['version'] = client.getVersion()
    options['plexbmc_version'] = options['version']
    options['myplex_user'] = settings('username')
    try:
        options['myport'] = int(settings('companionPort'))
        logMsg(title, 'Using Plex Companion Port %s' % str(options['myport']),
               0)
    except:
        logMsg(
            title, 'Error getting Plex Companion Port from file settings. '
            'Using fallback port 39005', -1)
        options['myport'] = 39005
    return options
Ejemplo n.º 49
0
    def getLogLevel(self):

        try:
            logLevel = int(utils.settings('logLevel'))
        except ValueError:
            logLevel = 0
        
        return logLevel
Ejemplo n.º 50
0
    def setUserPref(self):

        doUtils = self.doUtils.downloadUrl
        art = artwork.Artwork()

        url = "{server}/emby/Users/{UserId}?format=json"
        result = doUtils(url)
        self.userSettings = result
        # Set user image for skin display
        if result.get('PrimaryImageTag'):
            utils.window('EmbyUserImage', value=art.getUserArtwork(result['Id'], 'Primary'))

        # Set resume point max
        url = "{server}/emby/System/Configuration?format=json"
        result = doUtils(url)

        utils.settings('markPlayed', value=str(result['MaxResumePct']))
Ejemplo n.º 51
0
def build_global_catalog_item_url():
    """
    Build a URL to hit the global catalog service and do stuff with
    catalog items.
    """
    path = "/v1/catalog_item"
    base_url = "{0}".format(settings('global_catalog_url'))
    return "{0}{1}".format(base_url, path)
Ejemplo n.º 52
0
    def __init__(self):

        logLevel = self.getLogLevel()
        self.monitor = Monitor()

        window('plex_logLevel', value=str(logLevel))
        window('plex_kodiProfile',
               value=tryDecode(translatePath("special://profile")))
        window('plex_context',
               value='true' if settings('enableContext') == "true" else "")
        window('fetch_pms_item_number',
               value=settings('fetch_pms_item_number'))

        # Initial logging
        log.warn("======== START %s ========" % v.ADDON_NAME)
        log.warn("Platform: %s" % v.PLATFORM)
        log.warn("KODI Version: %s" % v.KODILONGVERSION)
        log.warn("%s Version: %s" % (v.ADDON_NAME, v.ADDON_VERSION))
        log.warn("Using plugin paths: %s"
                 % (settings('useDirectPaths') != "true"))
        log.warn("Number of sync threads: %s"
                 % settings('syncThreadNumber'))
        log.warn("Log Level: %s" % logLevel)
        log.warn("Full sys.argv received: %s" % argv)

        # Reset window props for profile switch
        properties = [
            "plex_online", "plex_serverStatus", "plex_onWake",
            "plex_dbCheck", "plex_kodiScan",
            "plex_shouldStop", "plex_dbScan",
            "plex_initialScan", "plex_customplayqueue", "plex_playbackProps",
            "plex_runLibScan", "pms_token", "plex_token",
            "pms_server", "plex_machineIdentifier", "plex_servername",
            "plex_authenticated", "PlexUserImage", "useDirectPaths",
            "kodiplextimeoffset", "countError", "countUnauthorized",
            "plex_restricteduser", "plex_allows_mediaDeletion",
            "plex_command", "plex_result", "plex_force_transcode_pix"
        ]
        for prop in properties:
            window(prop, clear=True)

        # Clear video nodes properties
        videonodes.VideoNodes().clearProperties()

        # Set the minimum database version
        window('plex_minDBVersion', value="1.5.10")
Ejemplo n.º 53
0
    def __init__(self):
        self.clientinfo = clientinfo.ClientInfo()
        self.addonName = self.clientinfo.getAddonName()

        self.enableTextureCache = utils.settings(
            'enableTextureCache') == "true"
        self.imageCacheLimitThreads = int(utils.settings("imageCacheLimit"))
        self.imageCacheLimitThreads = int(self.imageCacheLimitThreads * 5)
        utils.logMsg(
            "Using Image Cache Thread Count: " +
            str(self.imageCacheLimitThreads), 1)

        if not self.xbmc_port and self.enableTextureCache:
            self.setKodiWebServerDetails()

        self.userId = utils.window('emby_currUser')
        self.server = utils.window('emby_server%s' % self.userId)
Ejemplo n.º 54
0
 def _write_PMS_settings(self, url, token):
     """
     Sets certain settings for server by asking for the PMS' settings
     Call with url: scheme://ip:port
     """
     xml = get_PMS_settings(url, token)
     try:
         xml.attrib
     except AttributeError:
         log.error('Could not get PMS settings for %s' % url)
         return
     for entry in xml:
         if entry.attrib.get('id', '') == 'allowMediaDeletion':
             settings('plex_allows_mediaDeletion',
                      value=entry.attrib.get('value', 'true'))
             window('plex_allows_mediaDeletion',
                    value=entry.attrib.get('value', 'true'))
Ejemplo n.º 55
0
 def addSets(self, movieid, collections, kodicursor, API):
     for setname in collections:
         setid = self.createBoxset(setname)
         # Process artwork
         if settings('setFanartTV') == 'true':
             self.artwork.addArtwork(API.getSetArtwork(), setid, "set",
                                     kodicursor)
         self.assignBoxset(setid, movieid)
Ejemplo n.º 56
0
    def __init__(self):
        LOG.debug('Entering initialsetup class')
        self.plx = PlexAPI()
        self.dialog = xbmcgui.Dialog()

        self.server = UserClient().getServer()
        self.serverid = settings('plex_machineIdentifier')
        # Get Plex credentials from settings file, if they exist
        plexdict = self.plx.GetPlexLoginFromSettings()
        self.myplexlogin = plexdict['myplexlogin'] == 'true'
        self.plexLogin = plexdict['plexLogin']
        self.plexToken = plexdict['plexToken']
        self.plexid = plexdict['plexid']
        # Token for the PMS, not plex.tv
        self.pms_token = settings('accessToken')
        if self.plexToken:
            LOG.debug('Found a plex.tv token in the settings')
Ejemplo n.º 57
0
    def _server_restarting(cls):

        if settings('supressRestartMsg') == "true":
            dialog(type_="notification",
                   heading="{emby}",
                   message=lang(33006),
                   icon="{emby}")
        window('emby_online', value="false")
Ejemplo n.º 58
0
    def _auto_pick_pms(self):
        """
        Will try to pick PMS based on machineIdentifier saved in file settings
        but only once

        Returns server or None if unsuccessful
        """
        https_updated = False
        checked_plex_tv = False
        server = None
        while True:
            if https_updated is False:
                serverlist = PF.discover_pms(self.plex_token)
                for item in serverlist:
                    if item.get('machineIdentifier') == self.serverid:
                        server = item
                if server is None:
                    name = settings('plex_servername')
                    LOG.warn(
                        'The PMS you have used before with a unique '
                        'machineIdentifier of %s and name %s is '
                        'offline', self.serverid, name)
                    return
            chk = self._check_pms_connectivity(server)
            if chk == 504 and https_updated is False:
                # switch HTTPS to HTTP or vice-versa
                if server['scheme'] == 'https':
                    server['scheme'] = 'http'
                else:
                    server['scheme'] = 'https'
                https_updated = True
                continue
            if chk == 401:
                LOG.warn('Not yet authorized for Plex server %s',
                         server['name'])
                if self.check_plex_tv_sign_in() is True:
                    if checked_plex_tv is False:
                        # Try again
                        checked_plex_tv = True
                        https_updated = False
                        continue
                    else:
                        LOG.warn('Not authorized even though we are signed '
                                 ' in to plex.tv correctly')
                        dialog(
                            'ok', lang(29999), '%s %s' %
                            (lang(39214), try_encode(server['name'])))
                        return
                else:
                    return
            # Problems connecting
            elif chk >= 400 or chk is False:
                LOG.warn('Problems connecting to server %s. chk is %s',
                         server['name'], chk)
                return
            LOG.info('We found a server to automatically connect to: %s',
                     server['name'])
            return server
Ejemplo n.º 59
0
    def _AutoPickPMS(self):
        """
        Will try to pick PMS based on machineIdentifier saved in file settings
        but only once

        Returns server or None if unsuccessful
        """
        httpsUpdated = False
        checkedPlexTV = False
        server = None
        while True:
            if httpsUpdated is False:
                serverlist = self._getServerList()
                for item in serverlist:
                    if item.get('machineIdentifier') == self.serverid:
                        server = item
                if server is None:
                    name = settings('plex_servername')
                    log.warn('The PMS you have used before with a unique '
                             'machineIdentifier of %s and name %s is '
                             'offline' % (self.serverid, name))
                    # "PMS xyz offline"
                    self.dialog.notification(addonName,
                                             '%s %s' % (name, lang(39213)),
                                             xbmcgui.NOTIFICATION_ERROR, 7000,
                                             False)
                    return
            chk = self._checkServerCon(server)
            if chk == 504 and httpsUpdated is False:
                # Not able to use HTTP, try HTTPs for now
                server['scheme'] = 'https'
                httpsUpdated = True
                continue
            if chk == 401:
                log.warn('Not yet authorized for Plex server %s' %
                         server['name'])
                if self.CheckPlexTVSignIn() is True:
                    if checkedPlexTV is False:
                        # Try again
                        checkedPlexTV = True
                        httpsUpdated = False
                        continue
                    else:
                        log.warn('Not authorized even though we are signed '
                                 ' in to plex.tv correctly')
                        self.dialog.ok(addonName,
                                       '%s %s' % lang(39214) + server['name'])
                        return
                else:
                    return
            # Problems connecting
            elif chk >= 400 or chk is False:
                log.warn('Problems connecting to server %s. chk is %s' %
                         (server['name'], chk))
                return
            log.info('We found a server to automatically connect to: %s' %
                     server['name'])
            return server
Ejemplo n.º 60
0
    def getServer(self, prefix=True):
        # Original host
        self.servername = settings('plex_servername')
        HTTPS = settings('https') == "true"
        host = settings('ipaddress')
        port = settings('port')
        self.machineIdentifier = settings('plex_machineIdentifier')

        server = host + ":" + port

        if not host:
            LOG.debug("No server information saved.")
            return False

        # If https is true
        if prefix and HTTPS:
            server = "https://%s" % server
        # If https is false
        elif prefix and not HTTPS:
            server = "http://%s" % server
        # User entered IP; we need to get the machineIdentifier
        if self.machineIdentifier == '' and prefix is True:
            self.machineIdentifier = PF.GetMachineIdentifier(server)
            if self.machineIdentifier is None:
                self.machineIdentifier = ''
            settings('plex_machineIdentifier', value=self.machineIdentifier)
        LOG.debug('Returning active server: %s', server)
        return server