python类executeJSONRPC()的实例源码

def getJSONResponse(message):
    return simplejson.loads(xbmc.executeJSONRPC(message))

def get_xbmc_JSONRPC_response(json_query=""):
    try:
        response = xbmc.executeJSONRPC(json_query)
        response = unicode(response, 'utf-8', errors='ignore')
        response = json.loads(response)
        logger.info("streamondemand.channels.database jsonrpc %s" % response)
    except Exception, e:
        logger.info("streamondemand.channels.database jsonrpc error: %s" % str(e))
        response = None
    return response

def get_xbmc_jsonrpc_response(json_query=""):
    try:
        response = xbmc.executeJSONRPC(json_query)
        response = unicode(response, 'utf-8', errors='ignore')
        response = json.loads(response)
        logger.info("streamondemand.channels.database jsonrpc %s" % response)
    except Exception, e:
        logger.info("streamondemand.channels.database jsonrpc error: %s" % str(e))
        response = None
    return response

def get_xbmc_jsonrpc_response(json_query=""):
    try:
        response = xbmc.executeJSONRPC(json_query)
        response = unicode(response, 'utf-8', errors='ignore')
        response = json.loads(response)
        logger.info("streamondemand-pureita.channels.database jsonrpc %s" % response)
    except Exception, e:
        logger.info("streamondemand-pureita.channels.database jsonrpc error: %s" % str(e))
        response = None
    return response

def kodiJsonRequest(params):
    data = json.dumps(params)
    request = xbmc.executeJSONRPC(data)
    try:
        response = json.loads(request)
    except UnicodeDecodeError:
        response = json.loads(request.decode('utf-8', 'ignore'))
    try:
        if 'result' in response:
            return response['result']
        return None
    except KeyError:
        logger.warn("[%s] %s" % (params['method'], response['error']['message']))
        return None

def execute_jsonrpc(command):
    if not isinstance(command, basestring):
        command = json.dumps(command)
    response = xbmc.executeJSONRPC(command)
    return json.loads(response)

def add_dummy_favorite():
    json_rpc_command={"jsonrpc": "2.0",
                      "method": "Favourites.AddFavourite",
                      'params': {
                                 'title': 'dummy',
                                 'type': 'script',
                                 'path': 'dummy_command_enough_to_e_unique',
                                 },
                      'id': '1'
                      }
    a=xbmc.executeJSONRPC(json.dumps(json_rpc_command))
    log("dummy favorite:" + repr(a))

def json_query(query, ret):
    try:
        xbmc_request = json.dumps(query)
        result = xbmc.executeJSONRPC(xbmc_request)
        #print result
        #result = unicode(result, 'utf-8', errors='ignore')
        #log('result = ' + str(result))
        if ret:
            return json.loads(result)['result']
        else:
            return json.loads(result)
    except:
        return {}

#https://github.com/russellballestrini/nested-lookup/blob/master/nested_lookup/nested_lookup.py

def __init__(self, version, releasename, appname):
        super(XbmcSystemVersion, self).__init__(version, releasename, appname)
        try:
            json_query = xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Application.GetProperties", '
                                             '"params": {"properties": ["version", "name"]}, "id": 1 }')
            json_query = unicode(json_query, 'utf-8', errors='ignore')
            json_query = json.loads(json_query)

            version_installed = json_query['result']['version']
            self._version = (version_installed.get('major', 1), version_installed.get('minor', 0))
            self._appname = json_query['result']['name']
        except:
            self._version = (1, 0)  # Frodo
            self._appname = 'Unknown Application'

        self._releasename = 'Unknown Release'
        if (19, 0) > self._version >= (18, 0):
            self._releasename = 'Leia'
        elif self._version >= (17, 0):
            self._releasename = 'Krypton'
        elif self._version >= (16, 0):
            self._releasename = 'Jarvis'
        elif self._version >= (15, 0):
            self._releasename = 'Isengard'
        elif self._version >= (14, 0):
            self._releasename = 'Helix'
        elif self._version >= (13, 0):
            self._releasename = 'Gotham'
        elif self._version >= (12, 0):
            self._releasename = 'Frodo'

def get_kodi_json(method, params):
    json_query = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "%s", "params": %s, "id": 1}' % (method, params))
    json_query = unicode(json_query, 'utf-8', errors='ignore')
    return json.loads(json_query)

def __init__(self, version, releasename, appname):
        super(XbmcSystemVersion, self).__init__(version, releasename, appname)
        try:
            json_query = xbmc.executeJSONRPC(
                '{ "jsonrpc": "2.0", "method": "Application.GetProperties", "params": {"properties": ["version", "name"]}, "id": 1 }')
            json_query = unicode(json_query, 'utf-8', errors='ignore')
            json_query = json.loads(json_query)
            version_installed = []
            version_installed = json_query['result']['version']
            self._version = (version_installed.get('major', 1), version_installed.get('minor', 0))
            self._appname = json_query['result']['name']
            pass
        except:
            self._version = (1, 0)  # Frodo
            self._appname = 'Unknown Application'
            pass
        self._releasename = 'Unknown XBMC Release'
        if self._version >= (12, 0):
            self._releasename = 'Frodo'
            pass
        if self._version >= (13, 0):
            self._releasename = 'Gotham'
            pass
        if self._version >= (14, 0):
            self._releasename = 'Helix'
            pass
        if self._version >= (15, 0):
            self._releasename = 'Isengard'
            pass
        if self._version >= (16, 0):
            self._releasename = 'Jarvis'
            pass
        if self._version >= (17, 0):
            self._releasename = 'Krypton'
            pass

def get_shows():
        postdata = json.dumps({"jsonrpc": "2.0",
                               "id": 1,
                               'method': 'VideoLibrary.GetTVShows',
                               "params": {
                                   "properties": ["imdbnumber"]
                               }})
        json_query = xbmc.executeJSONRPC(postdata)
        json_query = unicode(json_query, 'utf-8', errors='ignore')
        json_query = json.loads(json_query)['result']['tvshows']
        return json_query

def get_show_details(show_id):
        postdata = json.dumps({"jsonrpc": "2.0",
                               "id": 1,
                               'method': 'VideoLibrary.GetTVShowDetails',
                               "params": {
                                   'tvshowid': show_id,
                                   "properties": ["imdbnumber"]
                               }})
        json_query = xbmc.executeJSONRPC(postdata)
        json_query = unicode(json_query, 'utf-8', errors='ignore')
        json_query = json.loads(json_query)['result']['tvshowdetails']
        return json_query

def get_episodes(show_id):
        postdata = json.dumps({"jsonrpc": "2.0",
                               "id": 1,
                               'method': 'VideoLibrary.GetEpisodes',
                               "params": {
                                   'tvshowid': show_id,
                                   "properties": ["season", "episode", "playcount", "resume"]
                               }})
        json_query = xbmc.executeJSONRPC(postdata)
        json_query = json.loads(json_query)
        if 'error' in json_query:
            xbmc.log('%s: ERROR: %s' % (ADDONID, json_query['error']['stack']['message']))
            return None
        json_query = json_query['result']['episodes']
        return json_query

def set_watched(episode_id, watched):
        postdata = json.dumps({"jsonrpc": "2.0",
                               "id": 1,
                               'method': 'VideoLibrary.SetEpisodeDetails',
                               "params": {
                                   'episodeid': episode_id,
                                   'playcount': 1 if watched else 0,
                               }})
        xbmc.executeJSONRPC(postdata)

def ShowStats(self, showAddons = False):
        # Get all Files in Thumbnails folder and all Textures in Database
        self.ExploreThumbnailsFolder(thumbnailsFolder)
        jSonQuery = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Textures.GetTextures", "id": 1}')
        jSon = json.loads(jSonQuery)
        try:
            if jSon['result'].has_key('textures'): getTextures = jSon['result']['textures']
        except: getTextures = []

        statsT = normalize(addonLanguage(32108)) + ": " + humanReadableSizeOf(self.thumbnailFileSize) + ", " + str(len(self.thumbnailFileList)) + " " + normalize(addonLanguage(32107)) + ", " + str(len(getTextures)) + " " + normalize(addonLanguage(32108))
        statsA = ""

        if showAddons:
            # Compute addon size and number of files.
            totalAddonSize = 0
            totalAddonFiles = 0
            addonData = os.path.join(userdataFolder, "addon_data")
            for item in os.listdir(addonData):
                totalAddonSize = totalAddonSize + self.GetFolderSize(os.path.join(addonData, item))
                totalAddonFiles = totalAddonFiles + 1
            addonRollback = os.path.join(homeFolder, "addons", "packages")
            for item in os.listdir(addonRollback):
                totalAddonSize = totalAddonSize + os.stat(os.path.join(addonRollback, item)).st_size
                totalAddonFiles = totalAddonFiles + 1

            statsA = normalize(addonLanguage(32109)) + ": " + humanReadableSizeOf(totalAddonSize) + ", " + str(totalAddonFiles) + " " + normalize(addonLanguage(32107))

        # Show stats
        xbmcgui.Dialog().ok(addonName + " - " + normalize(addonLanguage(32106)), statsT, statsA)

def getInputstreamAddon():
    r = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "id": 1, "method": "Addons.GetAddonDetails", "params": {"addonid":"inputstream.adaptive", "properties": ["enabled"]}}')
    data = json.loads(r)
    if not "error" in data.keys():
        if data["result"]["addon"]["enabled"] == True:
            return True

    return None

def getJSON(self,method,params):
        json_response = xbmc.executeJSONRPC('{ "jsonrpc" : "2.0" , "method" : "' + method + '" , "params" : ' + params + ' , "id":1 }')
        jsonobject = json.loads(json_response.decode('utf-8','replace'))       
        if(jsonobject.has_key('result')):
            return jsonobject['result']
        else:
            self.log("no result " + str(jsonobject),xbmc.LOGDEBUG)
            return None

def check_plg():
  js_resp = xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.GetAddons", "id":1}')
  if int(xbmc.getInfoLabel("System.BuildVersion" )[0:2]) > 14: ln = 1
  else: ln = 2

  if len(re.findall(r'blstfusion', js_resp)) > ln:
    Notify ('%s %s' % (__scriptname__, __version__) , '[COLOR FFFF0000]confilct ![/COLOR]')
    return False
  else:
    return True

def get_data(payload):
    """
    obtiene la información de la llamada JSON-RPC con la información pasada en payload
    @type payload: dict
    @param payload: data
    :return:
    """
    logger.info("payload: %s" % payload)
    # Required header for XBMC JSON-RPC calls, otherwise you'll get a 415 HTTP response code - Unsupported media type
    headers = {'content-type': 'application/json'}

    if config.get_setting("library_mode", "biblioteca"):
        try:
            try:
                xbmc_port = config.get_setting("xbmc_puerto", "biblioteca")
            except:
                xbmc_port = 0

            xbmc_json_rpc_url = "http://" + config.get_setting("xbmc_host", "biblioteca") + ":" + str(
                xbmc_port) + "/jsonrpc"
            req = urllib2.Request(xbmc_json_rpc_url, data=jsontools.dump_json(payload), headers=headers)
            f = urllib2.urlopen(req)
            response = f.read()
            f.close()

            logger.info("get_data: response %s" % response)
            data = jsontools.load_json(response)
        except Exception, ex:
            template = "An exception of type {0} occured. Arguments:\n{1!r}"
            message = template.format(type(ex).__name__, ex.args)
            logger.error("get_data: error en xbmc_json_rpc_url: %s" % message)
            data = ["error"]
    else:
        try:
            data = jsontools.load_json(xbmc.executeJSONRPC(jsontools.dump_json(payload)))
        except Exception, ex:
            template = "An exception of type {0} occured. Arguments:\n{1!r}"
            message = template.format(type(ex).__name__, ex.args)
            logger.error("get_data:: error en xbmc.executeJSONRPC: {0}".
                        format(message))
            data = ["error"]

    logger.info("data: %s" % data)

    return data