Example #1
0
    def _run_addon(self, type, addon_basename):
        """
        """
        xbmc.log("_run_addon %s", xbmc.LOGDEBUG)
        result = True
        if (type == TYPE_ADDON_VIDEO):
            command = "XBMC.ActivateWindow(10025,%s/)" % (os.path.join(
                get_install_path(type), addon_basename))

        elif (type == TYPE_ADDON_MUSIC):
            command = "XBMC.ActivateWindow(10502,plugin://addons/%s/)" % (
                addon_basename, )
        elif (type == TYPE_ADDON_PROGRAMS):
            command = "XBMC.ActivateWindow(10001,plugin://addons/%s/)" % (
                addon_basename, )
        elif (type == TYPE_ADDON_PICTURES):
            command = "XBMC.ActivateWindow(10002,plugin://addons/%s/)" % (
                addon_basename, )
        elif (type == TYPE_ADDON_SCRIPT):
            command = "XBMC.RunScript(%s)" % (os.path.join(
                get_install_path(type), addon_basename, "default.py"), )

        try:
            xbmc.executebuiltin(command)
        except:
            print_exc()
            result = False
        return result
Example #2
0
    def _run_addon( self, type, addon_basename ):
        """
        """
        xbmc.log("_run_addon %s", xbmc.LOGDEBUG)
        result = True
        if ( type == TYPE_ADDON_VIDEO ):
            command = "XBMC.ActivateWindow(10025,%s/)" % ( os.path.join( get_install_path( type ), addon_basename) )

        elif ( type == TYPE_ADDON_MUSIC ):
            command = "XBMC.ActivateWindow(10502,plugin://addons/%s/)" % ( addon_basename, )
        elif ( type == TYPE_ADDON_PROGRAMS ):
            command = "XBMC.ActivateWindow(10001,plugin://addons/%s/)" % ( addon_basename, )
        elif ( type == TYPE_ADDON_PICTURES ):
            command = "XBMC.ActivateWindow(10002,plugin://addons/%s/)" % ( addon_basename, )
        elif ( type == TYPE_ADDON_SCRIPT ):
            command = "XBMC.RunScript(%s)" % ( os.path.join( get_install_path( type ), addon_basename, "default.py" ), )

        try:
            xbmc.executebuiltin( command )
        except:
            print_exc()
            result = False
        return result
Example #3
0
def isLibInstalled(id, type = TYPE_ADDON_MODULE, name = ""):
    """
    Check if a lib/module is already install and return the version of the current installed version
    """
    libVersion = None
    installPath = get_install_path( type )
    if type == TYPE_ADDON_MODULE:
        name = id
    libpath = os.path.join( installPath, name )
    if os.path.exists( libpath ):
        # Get version
        libInfo = getInstalledAddonInfo( os.path.join( libpath ) )
        libVersion = libInfo[ "version" ]

    return libVersion
Example #4
0
def isLibInstalled(id, type=TYPE_ADDON_MODULE, name=""):
    """
    Check if a lib/module is already install and return the version of the current installed version
    """
    libVersion = None
    installPath = get_install_path(type)
    if type == TYPE_ADDON_MODULE:
        name = id
    libpath = os.path.join(installPath, name)
    if os.path.exists(libpath):
        # Get version
        libInfo = getInstalledAddonInfo(os.path.join(libpath))
        libVersion = libInfo["version"]

    return libVersion
Example #5
0
    def _getAddonRequiredLibs ( self, addonIdList, repoId = None):
        """
        Display the addons to install for a repository
        """
        status = "OK"

        # List of repositories we will look in order to find the required modules
        repoList = [ getInstalledAddonInfo( os.path.join( DIR_ADDON_REPO, REPO_ID_XBMC4XBOX) ) ]
        if repoId:
            repoList.extend( [ getInstalledAddonInfo( os.path.join( DIR_ADDON_REPO, repoId) ) ] )
        repoList.extend( [ getInstalledAddonInfo( os.path.join( DIR_ADDON_REPO, REPO_ID_XBMC) ) ] )

        # Check if required lib already exist - we do an additional check later for non script modules once we have the module name from the addons repo
        addonIdCheck = []
        addonIdCheck.extend(addonIdList)
        for requiredlib in addonIdCheck:
            localLibVersion = isLibInstalled( requiredlib['id'] )
            if localLibVersion:
                xbmc.log("Requested %s version %s - found version %s" % (requiredlib['id'], requiredlib["version"], localLibVersion), xbmc.LOGDEBUG)
                if versionsCmp( localLibVersion, requiredlib["version"] ) >= 0:
                    addonIdList.remove(requiredlib)

                else:
                    installPath = get_install_path( TYPE_ADDON_MODULE )
                    fileMgr().deleteDir( os.path.join( installPath, requiredlib['id'] ) )

        if len(addonIdList) == 0:
            xbmc.log("No required libs", xbmc.LOGDEBUG)
            return "OK"

        # Parse each repository in the list and try to find in it the required module
        if len(addonIdList) > 0:
            allLibsFound = False
            for repoInfo in repoList:
                # Retrieving addons.xml from remote repository
                xmlInfofPath = os.path.join( DIR_CACHE, repoInfo [ "id" ] + ".xml")
                if fileOlderThan(xmlInfofPath, 60 * 30):
                    data = readURL( repoInfo [ "repo_url" ], save=True, localPath=xmlInfofPath )

                if ( os.path.exists( xmlInfofPath ) ):
                    try:
                        xmlData = open( os.path.join( xmlInfofPath ), "r" )
                        listAddonsXml = ListItemFromXML(xmlData)
                        xmlData.close()
                    except:
                        print_exc()

                    keepParsingCurrentRepo = True
                    while (keepParsingCurrentRepo):
                        item = listAddonsXml.getNextItem()
                        if item:
                            if len(addonIdList) > 0:
                                for lib in addonIdList:
                                    if lib["id"] == item['id']:
                                        localLibVersion = isLibInstalled( item['id'], item['type'], item['name'] )
                                        if localLibVersion:
                                            xbmc.log("Requested %s version %s - found version %s" % (requiredlib['id'], requiredlib["version"], localLibVersion), xbmc.LOGDEBUG)
                                            if versionsCmp( localLibVersion, lib["version"] ) >= 0:
                                                addonIdList.remove(lib)
                                                continue
                                            else:
                                                name = item['name']
                                                if item['type'] == TYPE_ADDON_MODULE:
                                                    name = item['id']
                                                installPath = get_install_path( item['type'] )
                                                fileMgr().deleteDir( os.path.join( installPath, name ) )

                                        endRepoChar = "/"
                                        if repoInfo [ "repo_datadir" ].endswith( "/" ):
                                            endRepoChar = ""

                                        if repoInfo [ "repo_format" ] ==  'zip':
                                            downloadUrl = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/' + item["id"]  + '-' + item["version"] + ".zip").replace(' ', '%20')
                                            changelog   = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/' + "changelog" + '-' + item["version"] + ".txt").replace(' ', '%20')
                                            iconimage   = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/' + "icon.png").replace(' ', '%20')
                                        else:
                                            downloadUrl = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/').replace(' ', '%20')
                                            changelog   = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/' + "changelog" + ".txt").replace(' ', '%20')
                                            iconimage   = (repoInfo [ "repo_datadir" ] + endRepoChar + item["id"] + '/' + "icon.png").replace(' ', '%20')
                                        item["ImageUrl"] = iconimage
                                        item["changelog"] = changelog

                                        xbmc.log("Download URL: %s" % (downloadUrl), xbmc.LOGDEBUG)

                                        # Install lib
                                        installMgr = InstallMgr()
                                        status, itemName, destination, addonInstaller = installMgr.install_from_repo( item['name'].encode('utf8'), downloadUrl, repoInfo[ "repo_format" ], repoInfo[ "repo_datadir" ] )
                                        if status == "OK":
                                            status, destination = addonInstaller.installItem()
                                            if status == "OK":
                                                saveLocalAddonInfo(repoInfo[ "id" ], destination, addonInstaller)
                                            # recursively install further dependencies
                                            requiredLibs = addonInstaller.itemInfo[ "required_lib" ]
                                            if len(requiredLibs) > 0:
                                                status = self._getAddonRequiredLibs ( addonInstaller.itemInfo[ "required_lib" ], repoInfo[ "id" ] )
                                                if status != "OK":
                                                    return status
                                        else:
                                            # Notify user it is impossible to install the current kib and check if he want to continue
                                            if not xbmcgui.Dialog().yesno( item['name'].encode('utf8'), __language__( 30070 ), __language__( 30071 ), __language__( 30072 ) ):
                                                keepParsingCurrentRepo = False
                                                allLibsFound = True
                                                status = "CANCELED"
                                                xbmc.log("User cancelled due to error of a lib install", xbmc.LOGDEBUG)
                                            else:
                                                # User wants to continue
                                                status = "OK"
                                        # Module installed or already installed - Remove it for the list of libs to install
                                        addonIdList.remove(lib)
                            else:
                                # No lib to find remaining
                                keepParsingCurrentRepo = False
                                allLibsFound = True
                        else:
                            keepParsingCurrentRepo = False
                if not allLibsFound:
                    # all libs found, no need to go to parse next repo
                    continue
            if len(addonIdList) > 0:
                xbmc.log("Not all required lib has been installed", xbmc.LOGDEBUG)

                if not xbmcgui.Dialog().yesno( lib['id'], __language__( 30070 ), __language__( 30071 ), __language__( 30072 ) ):
                    xbmc.log("User cancelled due to error of a lib install", xbmc.LOGDEBUG)
                    allLibsFound = True
                    status = "CANCELED"
                else:
                    # User wants to continue

                    # Update list of module which fail to install
                    #self.addMissingModules(addonIdList)
                    addMissingModules2DB(addonIdList)

                    status = "OK"

        return status#, itemName, destination, addonInstaller