Python utils.settings函数代码示例

    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

    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

    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")

    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

 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

    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

    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)

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

 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': '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")

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)

    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

 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

 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())

    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

    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