Merge branch 'master' into jarvis

.github/stale-dontuse.yml

@@ -1,18 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 31
-# Number of days of inactivity before a stale Issue or Pull Request is closed
-daysUntilClose: 14 
-# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
-onlyLabels:
-  - waiting for info
-  - wontfix
-
-# Label to use when marking as stale
-staleLabel: inactive
-
-# Comment to post when marking as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as inactive because it has not had
-  recent activity. It will be closed if no further activity occurs.

.travis.yml

@@ -1,13 +0,0 @@
-dist: xenial
-language: python
-python: 3.7
-
-install:
-  - pip install kodi-addon-checker
-
-before_script:
-- git config core.quotepath false
-
-# command to run our tests
-script:
-  - kodi-addon-checker --branch=krypton --allow-folder-id-mismatch

README.md

@@ -1,7 +1,6 @@
 # Backup Addon
-[![Build Status](https://travis-ci.org/robweber/xbmcbackup.svg?branch=master)](https://travis-ci.org/robweber/xbmcbackup)
 
-__Kodi Version Compatibility:__ Kodi 17.x (Krypton) and greater
+__Kodi Version Compatibility:__ Kodi 16.x (Jarvis) and greater
 
 ## About
 
@@ -20,11 +19,6 @@ For more specific information please check out the [wiki on Github](https://gith
 * [FAQ](https://github.com/robweber/xbmcbackup/wiki/FAQ) 
 
 
-## Attributions
-
-Icon files from Open Iconic — www.useiconic.com/open
-
-
 
 
 

addon.xml

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <addon id="script.xbmcbackup"
-    name="Backup" version="1.5.1" provider-name="robweber">
+    name="Backup" version="1.1.3" provider-name="robweber">
   <requires>
 	<!-- jarvis -->
-    <import addon="xbmc.python" version="2.25.0"/>
+    <import addon="xbmc.python" version="2.24.0"/>
     <import addon="script.module.httplib2" version="0.8.0" />
     <import addon="script.module.oauth2client" version="4.1.2" />
     <import addon="script.module.uritemplate" version="0.6" />
@@ -87,16 +87,10 @@
     <license>The MIT License</license>
     <forum>https://forum.kodi.tv/showthread.php?tid=129499</forum>
     <source>https://github.com/robweber/xbmcbackup</source>
-    <email></email>
+    <news>Version 1.1.4
-    <assets>
+- added file chunk support for dropbox uploads
-    	<icon>resources/images/icon.png</icon>
+- fixed settings duplicate ids, thanks aster-anto
-		<screenshot>resources/images/screenshot1.png</screenshot>
+- added scheduler delay to assist with time sync (rpi mostly)
-		<screenshot>resources/images/screenshot2.png</screenshot>
-		<screenshot>resources/images/screenshot3.png</screenshot>
-		<screenshot>resources/images/screenshot4.png</screenshot>
-    </assets>
-    <news>Version 1.5.1
-- fix guisettings restores not working - thanks Bluerayx
    	</news>
   </extension>
 </addon>

authorize_cloud.py

@@ -0,0 +1,37 @@
+import sys
+import urlparse
+import xbmcgui
+import resources.lib.utils as utils
+from resources.lib.authorizers import DropboxAuthorizer,GoogleDriveAuthorizer
+
+def get_params():
+    param = {}
+    try:
+        for i in sys.argv:
+            args = i
+            if(args.startswith('?')):
+                args = args[1:]
+            param.update(dict(urlparse.parse_qsl(args)))
+    except:
+        pass
+    return param
+
+params = get_params()
+
+#drobpox
+if(params['type'] == 'dropbox'):
+    authorizer = DropboxAuthorizer()
+
+    if(authorizer.authorize()):
+        xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30027) + ' ' + utils.getString(30106))
+    else:
+        xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30107) + ' ' + utils.getString(30027))
+
+#google drive
+elif(params['type'] == 'google_drive'):
+    authorizer = GoogleDriveAuthorizer()
+
+    if(authorizer.authorize()):
+        xbmcgui.Dialog().ok("Backup",utils.getString(30098) + ' ' + utils.getString(30106))
+    else:
+        xbmcgui.Dialog().ok("Backup",utils.getString(30107) + ' ' + utils.getString(30098))

changelog.txt

@@ -1,11 +1,3 @@
-Version 1.5.1
-
-fix guisettings restores not working - thanks Bluerayx
-
-Version 1.5.0
-
-Overhaul of file selection and restore procedures. Breaking Change with previous versions PR117
-
 Version 1.1.3
 
 added file chunk support for dropbox uploads

default.py

@@ -1,5 +1,5 @@
-import sys, urlparse
+import urlparse
-import xbmc, xbmcgui
+import xbmcgui
 import resources.lib.utils as utils
 from resources.lib.backup import XbmcBackup
 
@@ -28,15 +28,8 @@ if("mode" in params):
 
 #if mode wasn't passed in as arg, get from user
 if(mode == -1):
-    #by default, Backup,Restore,Open Settings
-    options = [utils.getString(30016),utils.getString(30017),utils.getString(30099)]
-    
-    #find out if we're using the advanced editor
-    if(int(utils.getSetting('backup_selection_type')) == 1):
-        options.append(utils.getString(30125))
-
     #figure out if this is a backup or a restore from the user
-    mode = xbmcgui.Dialog().select(utils.getString(30010) + " - " + utils.getString(30023),options)
+    mode = xbmcgui.Dialog().select(utils.getString(30010) + " - " + utils.getString(30023),[utils.getString(30016),utils.getString(30017),utils.getString(30099)])
 
 #check if program should be run
 if(mode != -1):
@@ -46,9 +39,7 @@ if(mode != -1):
     if(mode == 2):
         #open the settings dialog
         utils.openSettings()
-    elif(mode == 3 and int(utils.getSetting('backup_selection_type')) == 1):
+
-        #open the advanced editor
-        xbmc.executebuiltin('RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=advanced_editor)')
     elif(backup.remoteConfigured()):
 
         if(mode == backup.Restore):
@@ -79,12 +70,7 @@ if(mode != -1):
             if(selectedRestore != -1):
                 backup.selectRestore(restorePoints[selectedRestore][0])
                     
-            if('sets' in params):
+        backup.run(mode)
-                backup.restore(selectedSets=params['sets'].split('|'))
-            else:
-                backup.restore()
-        else:
-            backup.backup()
     else:
         #can't go any further
         xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30045))

launcher.py

@@ -1,64 +0,0 @@
-import sys
-import urlparse
-import xbmc
-import xbmcgui
-import xbmcvfs
-import resources.lib.utils as utils
-from resources.lib.authorizers import DropboxAuthorizer,GoogleDriveAuthorizer
-from resources.lib.advanced_editor import AdvancedBackupEditor
-
-
-#launcher for various helpful functions found in the settings.xml area
-
-def authorize_cloud(cloudProvider):
-    #drobpox
-    if(cloudProvider == 'dropbox'):
-        authorizer = DropboxAuthorizer()
-
-        if(authorizer.authorize()):
-            xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30027) + ' ' + utils.getString(30106))
-        else:
-            xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30107) + ' ' + utils.getString(30027))
-
-    #google drive
-    elif(cloudProvider == 'google_drive'):
-        authorizer = GoogleDriveAuthorizer()
-
-        if(authorizer.authorize()):
-            xbmcgui.Dialog().ok("Backup",utils.getString(30098) + ' ' + utils.getString(30106))
-        else:
-            xbmcgui.Dialog().ok("Backup",utils.getString(30107) + ' ' + utils.getString(30098))
-
-def remove_auth():
-    #triggered from settings.xml - asks if user wants to delete OAuth token information
-    shouldDelete = xbmcgui.Dialog().yesno(utils.getString(30093),utils.getString(30094),utils.getString(30095),autoclose=7000)
-
-    if(shouldDelete):
-        #delete any of the known token file types
-        xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "tokens.txt")) #dropbox
-        xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "google_drive.dat")) #google drive
-    
-def get_params():
-    param = {}
-    try:
-        for i in sys.argv:
-            args = i
-            if(args.startswith('?')):
-                args = args[1:]
-            param.update(dict(urlparse.parse_qsl(args)))
-    except:
-        pass
-    return param
-
-params = get_params()
-
-if(params['action'] == 'authorize_cloud'):
-    authorize_cloud(params['provider'])
-elif(params['action'] == 'remove_auth'):
-    remove_auth()
-elif(params['action'] == 'advanced_editor'):
-    editor = AdvancedBackupEditor()
-    editor.showMainScreen()
-elif(params['action'] == 'advanced_copy_config'):
-    editor = AdvancedBackupEditor()
-    editor.copySimpleConfig()

remove_auth.py

@@ -0,0 +1,13 @@
+import xbmc
+import xbmcgui
+import xbmcvfs
+import resources.lib.utils as utils
+
+#triggered from settings.xml - asks if user wants to delete OAuth token information
+shouldDelete = xbmcgui.Dialog().yesno(utils.getString(30093),utils.getString(30094),utils.getString(30095),autoclose=7000)
+
+if(shouldDelete):
+    #delete any of the known token file types
+    xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "tokens.txt")) #dropbox
+    xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "google_drive.dat")) #google drive
+    

resources/data/default_files.json

@@ -1,105 +0,0 @@
-{
-	"addons":{
-		"root":"special://home/addons/",
-		"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/addons/",
-				"recurse":true
-			},
-			{
-				"type":"exclude",
-				"path":"special://home/addons/packages/"
-			},
-			{
-				"type":"exclude",
-				"path":"special://home/addons/temp/"
-			}
-		]
-	},
-	"addon_data":{
-			"root":"special://home/userdata/addon_data/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/addon_data/",
-				"recurse":true
-			}
-		]
-	},
-	"database":{
-			"root":"special://home/userdata/Database/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/Database/",
-				"recurse":true
-			}
-		]
-	},
-	"game_saves":{
-			"root":"special://home/userdata/Savestates/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/Savestates/",
-				"recurse":true
-			}
-		]
-	},
-	"playlists":{
-			"root":"special://home/userdata/playlists/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/playlists/",
-				"recurse":true
-			}
-		]
-	},
-	"profiles":{
-			"root":"special://home/userdata/profiles/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/profiles/",
-				"recurse":true
-			}
-		]
-	},
-	"thumbnails":{
-			"root":"special://home/userdata/Thumbnails/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/Thumbnails/",
-				"recurse":true
-			}
-		]
-	},
-	"config":{
-			"root":"special://home/userdata/",
-			"dirs":[
-			{
-				"type":"include",
-				"path":"special://home/userdata/",
-				"recurse":false
-			},
-			{
-				"type":"include",
-				"path":"special://home/userdata/keymaps/",
-				"recurse":true
-			},
-			{
-				"type":"include",
-				"path":"special://home/userdata/peripheral_data/",
-				"recurse":true
-			},
-			{
-				"type":"include",
-				"path":"special://home/userdata/library/",
-				"recurse":true
-			}
-		]
-	}
-}

resources/language/resource.language.en_gb/strings.po

@@ -48,14 +48,6 @@ msgctxt "#30013"
 msgid "Scheduling"
 msgstr "Scheduling"
 
-msgctxt "#30014"
-msgid "Simple"
-msgstr "Simple"
-
-msgctxt "#30015"
-msgid "Advanced"
-msgstr "Advanced"
-
 msgctxt "#30016"
 msgid "Backup"
 msgstr "Backup"
@@ -137,12 +129,12 @@ msgid "Config Files"
 msgstr "Config Files"
 
 msgctxt "#30036"
-msgid "Disclaimer"
+msgid "Custom Directory 1"
-msgstr "Disclaimer"
+msgstr "Custom Directory 1"
 
 msgctxt "#30037"
-msgid "Canceling this menu will close and save changes"
+msgid "Custom Directory 2"
-msgstr "Canceling this menu will close and save changes"
+msgstr "Custom Directory 2"
 
 msgctxt "#30038"
 msgid "Advanced Settings Detected"
@@ -428,131 +420,3 @@ msgstr "Visit https://console.developers.google.com/"
 msgctxt "#30109"
 msgid "Run on startup if missed"
 msgstr "Run on startup if missed"
-
-msgctxt "#30110"
-msgid "Set Name"
-msgstr ""
-
-msgctxt "#30111"
-msgid "Root folder selection"
-msgstr ""
-
-msgctxt "#30112"
-msgid "Browse Folder"
-msgstr ""
-
-msgctxt "#30113"
-msgid "Enter Own"
-msgstr ""
-
-msgctxt "#30114"
-msgid "starts in Kodi home"
-msgstr ""
-
-msgctxt "#30115"
-msgid "enter path to start there"
-msgstr ""
-
-msgctxt "#30116"
-msgid "Enter root path"
-msgstr ""
-
-msgctxt "#30117"
-msgid "Path Error"
-msgstr ""
-
-msgctxt "#30118"
-msgid "Path does not exist"
-msgstr ""
-
-msgctxt "#30119"
-msgid "Select root"
-msgstr ""
-
-msgctxt "#30120"
-msgid "Add Exclude Folder"
-msgstr ""
-
-msgctxt "#30121"
-msgid "Root Folder"
-msgstr ""
-
-msgctxt "#30122"
-msgid "Edit"
-msgstr ""
-
-msgctxt "#30123"
-msgid "Delete"
-msgstr ""
-
-msgctxt "#30124"
-msgid "Choose Action"
-msgstr ""
-
-msgctxt "#30125"
-msgid "Advanced Editor"
-msgstr ""
-
-msgctxt "#30126"
-msgid "Add Set"
-msgstr ""
-
-msgctxt "#30127"
-msgid "Delete Set"
-msgstr ""
-
-msgctxt "#30128"
-msgid "Are you sure you want to delete?"
-msgstr ""
-
-msgctxt "#30129"
-msgid "Exclude"
-msgstr ""
-
-msgctxt "#30130"
-msgid "The root folder cannot be changed"
-msgstr ""
-
-msgctxt "#30131"
-msgid "Choose Sets to Restore"
-msgstr ""
-
-msgctxt "#30132"
-msgid "Version 1.5.0 requires you to setup your file selections again - this is a breaking change"
-msgstr ""
-
-msgctxt "#30133"
-msgid "Game Saves"
-msgstr ""
-
-msgctxt "#30134"
-msgid "Include"
-msgstr ""
-
-msgctxt "#30135"
-msgid "Add Include Folder"
-msgstr ""
-
-msgctxt "#30136"
-msgid "Path must be within root folder"
-msgstr ""
-
-msgctxt "#30137"
-msgid "This path is part of a rule already"
-msgstr ""
-
-msgctxt "#30138"
-msgid "Set Name exists already"
-msgstr ""
-
-msgctxt "#30139"
-msgid "Copy Simple Config"
-msgstr ""
-
-msgctxt "#30140"
-msgid "This will copy the default Simple file selection to the Advanced Editor"
-msgstr ""
-
-msgctxt "#30141"
-msgid "This will erase any current Advanced Editor settings"
-msgstr ""

resources/language/resource.language.en_us/strings.po

@@ -129,6 +129,14 @@ msgctxt "#30035"
 msgid "Config Files"
 msgstr "Config Files"
 
+msgctxt "#30036"
+msgid "Custom Directory 1"
+msgstr "Custom Directory 1"
+
+msgctxt "#30037"
+msgid "Custom Directory 2"
+msgstr "Custom Directory 2"
+
 msgctxt "#30038"
 msgid "Advanced Settings Detected"
 msgstr "Advanced Settings Detected"

resources/lib/advanced_editor.py

@@ -1,229 +0,0 @@
-import json
-import utils as utils
-import xbmcvfs
-import xbmc
-import xbmcgui
-
-class BackupSetManager:
-    jsonFile = xbmc.translatePath(utils.data_dir() + "custom_paths.json")
-    paths = None
-    
-    def __init__(self):
-        self.paths = {}
-        
-        #try and read in the custom file
-        self._readFile()
-
-    def addSet(self,aSet):
-        self.paths[aSet['name']] = {'root':aSet['root'],'dirs':[{"type":"include","path":aSet['root'],'recurse':True}]}
-
-        #save the file
-        self._writeFile()
-
-    def updateSet(self,name,aSet):
-        self.paths[name] = aSet
-
-        #save the file
-        self._writeFile()
-
-    def deleteSet(self,index):
-        #match the index to a key
-        keys = self.getSets()
-
-        #delete this set
-        del self.paths[keys[index]]
-
-        #save the file
-        self._writeFile()
-    
-    def getSets(self):
-        #list all current sets by name
-        keys = self.paths.keys()
-        keys.sort()
-
-        return keys
-
-    def getSet(self,index):
-        keys = self.getSets();
-
-        #return the set at this index
-        return {'name':keys[index],'set':self.paths[keys[index]]}
-
-    def validateSetName(self,name):
-        return (name not in self.getSets())
-
-    def _writeFile(self):
-        #create the custom file
-        aFile = xbmcvfs.File(self.jsonFile,'w')
-        aFile.write(json.dumps(self.paths))
-        aFile.close()
-    
-    def _readFile(self):
-        
-        if(xbmcvfs.exists(self.jsonFile)):
-
-            #read in the custom file
-            aFile = xbmcvfs.File(self.jsonFile)
-
-            #load custom dirs
-            self.paths = json.loads(aFile.read())
-            aFile.close()
-        else:
-            #write a blank file
-            self._writeFile()
-
-class AdvancedBackupEditor:
-    dialog = None
-
-    def __init__(self):
-        self.dialog = xbmcgui.Dialog()
-
-    def _cleanPath(self,root,path):
-        return path[len(root)-1:]
-
-    def _validatePath(self,root,path):
-        return path.startswith(root)
-
-    def createSet(self):
-        backupSet = None
-    
-        name = self.dialog.input(utils.getString(30110),defaultt='Backup Set')
-
-        if(name != None):
-
-            #give a choice to start in home or enter a root path
-            enterHome = self.dialog.yesno(utils.getString(30111),line1=utils.getString(30112) + " - " + utils.getString(30114),line2=utils.getString(30113) + " - " + utils.getString(30115),nolabel=utils.getString(30112),yeslabel=utils.getString(30113))
-
-            rootFolder = 'special://home'
-            if(enterHome):
-                rootFolder = self.dialog.input(utils.getString(30116),defaultt=rootFolder)
-
-                #direcotry has to end in slash
-                if(rootFolder[:-1] != '/'):
-                    rootFolder = rootFolder + '/'
-
-                #check that this path even exists
-                if(not xbmcvfs.exists(xbmc.translatePath(rootFolder))):
-                    self.dialog.ok(utils.getString(30117),utils.getString(30118),rootFolder)
-                    return None
-            else:
-                #select path to start set
-                rootFolder = self.dialog.browse(type=0,heading=utils.getString(30119),shares='files',defaultt=rootFolder)
-
-            backupSet = {'name':name,'root':rootFolder}
-    
-        return backupSet
-
-    def editSet(self,name,backupSet):
-        optionSelected = ''
-        rootPath = backupSet['root']
-        utils.log(rootPath)
-        while(optionSelected != -1):
-            options = [xbmcgui.ListItem(utils.getString(30120),"Exclude a specific folder from this backup set"),xbmcgui.ListItem(utils.getString(30135),"Include a specific folder to this backup set"),xbmcgui.ListItem(rootPath,utils.getString(30121))]
-
-            for aDir in backupSet['dirs']:
-                if(aDir['type'] == 'exclude'):
-                    options.append(xbmcgui.ListItem(self._cleanPath(rootPath,aDir['path']),"%s: %s" % ("Type",utils.getString(30129))))
-                elif(aDir['type'] == 'include'):
-                    options.append(xbmcgui.ListItem(self._cleanPath(rootPath,aDir['path']),"%s: %s | %s: %s" % ("Type",utils.getString(30134),"Include Sub Folders",str(aDir['recurse']))))
-
-            optionSelected = self.dialog.select(utils.getString(30122) + ' ' +  name,options,useDetails=True)
-
-            if(optionSelected == 0 or optionSelected == 1):
-                #add a folder, will equal root if cancel is hit
-                addFolder = self.dialog.browse(type=0,heading=utils.getString(30120),shares='files',defaultt=backupSet['root'])
-                
-                if(addFolder.startswith(rootPath)):
-                    
-                    if(not any(addFolder == aDir['path'] for aDir in backupSet['dirs'])):
-                        #cannot add root as an exclusion
-                        if(optionSelected == 0 and addFolder != backupSet['root']):
-                            backupSet['dirs'].append({"path":addFolder,"type":"exclude"})
-                        elif(optionSelected == 1):
-                            #can add root as inclusion
-                            backupSet['dirs'].append({"path":addFolder,"type":"include","recurse":True})
-                    else:
-                        #this path is already part of another include/exclude rule
-                        self.dialog.ok(utils.getString(30117),utils.getString(30137),addFolder)
-                else:
-                    #folder must be under root folder
-                    self.dialog.ok(utils.getString(30117), utils.getString(30136),rootPath)
-            elif(optionSelected == 2):
-                self.dialog.ok(utils.getString(30121),utils.getString(30130),backupSet['root'])
-            elif(optionSelected > 2):
-                
-                cOptions = ['Delete']
-                if(backupSet['dirs'][optionSelected - 3]['type'] == 'include'):
-                    cOptions.append('Toggle Sub Folders')
-                    
-                contextOption = self.dialog.contextmenu(cOptions)
-                
-                if(contextOption == 0):
-                    if(self.dialog.yesno(heading=utils.getString(30123),line1=utils.getString(30128))):
-                        #remove folder
-                        del backupSet['dirs'][optionSelected - 3]
-                elif(contextOption == 1 and backupSet['dirs'][optionSelected - 3]['type'] == 'include'):
-                    #toggle if this folder should be recursive
-                    backupSet['dirs'][optionSelected - 3]['recurse'] = not backupSet['dirs'][optionSelected - 3]['recurse']
-
-        return backupSet
-    
-
-    def showMainScreen(self):
-        exitCondition = ""
-        customPaths = BackupSetManager()
-
-        #show this every time
-        self.dialog.ok(utils.getString(30036),utils.getString(30037))
- 
-        while(exitCondition != -1):
-            #load the custom paths
-            options = [xbmcgui.ListItem(utils.getString(30126),'',utils.addon_dir() + '/resources/images/plus-icon.png')]
-        
-            for index in range(0,len(customPaths.getSets())):
-                aSet = customPaths.getSet(index)
-                options.append(xbmcgui.ListItem(aSet['name'],utils.getString(30121) + ': ' + aSet['set']['root'],utils.addon_dir() + '/resources/images/folder-icon.png'))
-            
-            #show the gui
-            exitCondition = self.dialog.select(utils.getString(30125),options,useDetails=True)
-        
-            if(exitCondition >= 0):
-                if(exitCondition == 0):
-                    newSet = self.createSet()
-
-                    #check that the name is unique
-                    if(customPaths.validateSetName(newSet['name'])):
-                        customPaths.addSet(newSet)
-                    else:
-                        self.dialog.ok(utils.getString(30117), utils.getString(30138),newSet['name'])
-                else:
-                    #bring up a context menu
-                    menuOption = self.dialog.contextmenu([utils.getString(30122),utils.getString(30123)])
-
-                    if(menuOption == 0):
-                        #get the set
-                        aSet = customPaths.getSet(exitCondition -1)
-                        
-                        #edit the set
-                        updatedSet = self.editSet(aSet['name'],aSet['set'])
-
-                        #save it
-                        customPaths.updateSet(aSet['name'],updatedSet)
-                    
-                    elif(menuOption == 1):
-                        if(self.dialog.yesno(heading=utils.getString(30127),line1=utils.getString(30128))):
-                            #delete this path - subtract one because of "add" item
-                            customPaths.deleteSet(exitCondition -1)
-
-    def copySimpleConfig(self):
-        #disclaimer in case the user hit this on accident
-        shouldContinue = self.dialog.yesno(utils.getString(30139),utils.getString(30140),utils.getString(30141))
-
-        if(shouldContinue):
-            source = xbmc.translatePath(utils.addon_dir() + "/resources/data/default_files.json")
-            dest = xbmc.translatePath(utils.data_dir() + "/custom_paths.json")
-
-            xbmcvfs.copy(source,dest)
-
-              
-

resources/lib/authorizers.py

@@ -3,18 +3,9 @@ import xbmcgui
 import xbmcvfs
 import resources.lib.tinyurl as tinyurl
 import resources.lib.utils as utils
-
+import dropbox
-#don't die on import error yet, these might not even get used
+from resources.lib.pydrive.auth import GoogleAuth
-try:
+from resources.lib.pydrive.drive import GoogleDrive
-    import dropbox
-except ImportError:
-    pass
-
-try:
-    from resources.lib.pydrive.auth import GoogleAuth
-    from resources.lib.pydrive.drive import GoogleDrive
-except ImportError:
-    pass
 
 class DropboxAuthorizer:
     APP_KEY = ""

resources/lib/backup.py

@@ -4,8 +4,6 @@ import xbmcvfs
 import utils as utils
 import time
 import json
-import os
-from datetime import datetime
 from vfs import XBMCFileSystem,DropboxFileSystem,ZipFileSystem,GoogleDriveFilesystem
 from progressbar import BackupProgressBar
 from resources.lib.guisettings import GuiSettingsManager
@@ -25,9 +23,6 @@ class XbmcBackup:
     Backup = 0
     Restore = 1
 
-    #list of dirs for the "simple" file selection
-    simple_directory_list = ['addons','addon_data','database','game_saves','playlists','profiles','thumbnails','config']
-
     #file systems
     xbmc_vfs = None
     remote_vfs = None
@@ -41,6 +36,7 @@ class XbmcBackup:
     filesLeft = 0
     filesTotal = 1
 
+    fileManager = None
     restore_point = None
     skip_advanced = False   #if we should check for the existance of advancedsettings in the restore
     
@@ -73,8 +69,7 @@ class XbmcBackup:
 
         return result
 
-    #reverse - should reverse the resulting, default is true - newest to oldest
+    def listBackups(self):
-    def listBackups(self,reverse=True):
         result = []
 
         #get all the folders in the current root path
@@ -83,8 +78,12 @@ class XbmcBackup:
         for aDir in dirs:
             if(self.remote_vfs.exists(self.remote_base_path + aDir + "/xbmcbackup.val")):
 
-                #format the name according to regional settings
+                #folder may or may not contain time, older versions didn't include this
-                folderName = self._dateFormat(aDir)
+                folderName = ''
+                if(len(aDir) > 8):
+                    folderName = aDir[6:8] + '-' + aDir[4:6] + '-' + aDir[0:4] + " " + aDir[8:10] + ":" + aDir[10:12]
+                else:
+                    folderName = aDir[6:8] + '-' + aDir[4:6] + '-' + aDir[0:4]
 
                 result.append((aDir,folderName))
 
@@ -92,15 +91,18 @@ class XbmcBackup:
             file_ext = aFile.split('.')[-1]
             folderName = utils.encode(aFile.split('.')[0])
             
-            if(file_ext == 'zip' and len(folderName) == 12 and str.isdigit(folderName)):
+            if(file_ext == 'zip' and (len(folderName) == 12 or len(folderName) == 8) and str.isdigit(folderName)):
                 
-                #format the name according to regional settings
+                #folder may or may not contain time, older versions didn't include this
-                folderName = self._dateFormat(folderName)
+                if(len(aFile ) > 8):
+                    folderName = aFile [6:8] + '-' + aFile [4:6] + '-' + aFile [0:4] + " " + aFile [8:10] + ":" + aFile [10:12]
+                else:
+                    folderName = aFile [6:8] + '-' + aFile [4:6] + '-' + aFile [0:4]
 
                 result.append((aFile ,folderName))
                 
 
-        result.sort(key=folderSort,reverse=reverse)
+        result.sort(key=folderSort)
         
         return result
 
@@ -110,10 +112,46 @@ class XbmcBackup:
     def skipAdvanced(self):
         self.skip_advanced = True
 
-    def backup(self,progressOverride=False):
+    def run(self,mode=-1,progressOverride=False):
-        shouldContinue = self._setupVFS(self.Backup,progressOverride)
+        #set windows setting to true
+        window = xbmcgui.Window(10000)
+        window.setProperty(utils.__addon_id__ + ".running","true")
         
-        if(shouldContinue):
+        #append backup folder name
+        progressBarTitle = utils.getString(30010) + " - "
+        if(mode == self.Backup and self.remote_vfs.root_path != ''):
+            if(utils.getSetting("compress_backups") == 'true'):
+                #delete old temp file
+                if(self.xbmc_vfs.exists(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
+                    if(not self.xbmc_vfs.rmfile(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
+                        #we had some kind of error deleting the old file
+                        xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30096),utils.getString(30097))
+                        return
+                    
+                #save the remote file system and use the zip vfs
+                self.saved_remote_vfs = self.remote_vfs
+                self.remote_vfs = ZipFileSystem(xbmc.translatePath("special://temp/xbmc_backup_temp.zip"),"w")
+                
+            self.remote_vfs.set_root(self.remote_vfs.root_path + time.strftime("%Y%m%d%H%M") + "/")
+            progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30016)
+        elif(mode == self.Restore and self.restore_point != None and self.remote_vfs.root_path != ''):
+            if(self.restore_point.split('.')[-1] != 'zip'):
+                self.remote_vfs.set_root(self.remote_vfs.root_path + self.restore_point + "/")
+            progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30017)
+        else:
+            #kill the program here
+            self.remote_vfs = None
+            return
+
+        utils.log(utils.getString(30047) + ": " + self.xbmc_vfs.root_path)
+        utils.log(utils.getString(30048) + ": " + self.remote_vfs.root_path)
+
+        
+        #setup the progress bar
+        self.progressBar = BackupProgressBar(progressOverride)
+        self.progressBar.create(progressBarTitle,utils.getString(30049) + "......")
+
+        if(mode == self.Backup):
             utils.log(utils.getString(30023) + " - " + utils.getString(30016))
             #check if remote path exists
             if(self.remote_vfs.exists(self.remote_vfs.root_path)):
@@ -123,37 +161,8 @@ class XbmcBackup:
                 #make the remote directory
                 self.remote_vfs.mkdir(self.remote_vfs.root_path)
 
-            utils.log(utils.getString(30051))
-            utils.log('File Selection Type: ' + str(utils.getSetting('backup_selection_type')))
-            allFiles = []
-
-            if(int(utils.getSetting('backup_selection_type')) == 0):
-                #read in a list of the directories to backup
-                selectedDirs = self._readBackupConfig(utils.addon_dir() + "/resources/data/default_files.json")
-                
-                #simple mode - get file listings for all enabled directories
-                for aDir in self.simple_directory_list:
-                    #if this dir enabled
-                    if(utils.getSetting('backup_' + aDir) == 'true'):
-                        #get a file listing and append it to the allfiles array
-                        allFiles.append(self._addBackupDir(aDir,selectedDirs[aDir]['root'],selectedDirs[aDir]['dirs']))
-            else:
-                #advanced mode - load custom paths
-                selectedDirs = self._readBackupConfig(utils.data_dir() + "/custom_paths.json")
-
-                #get the set names
-                keys = selectedDirs.keys()
-                
-                #go through the custom sets
-                for aKey in keys:
-                    #get the set
-                    aSet = selectedDirs[aKey]
-                    
-                    #get file listing and append
-                    allFiles.append(self._addBackupDir(aKey,aSet['root'],aSet['dirs']))
-                
             #create a validation file for backup rotation
-            writeCheck = self._createValidationFile(allFiles)
+            writeCheck = self._createValidationFile()
             
             if(not writeCheck):
                 #we may not be able to write to this destination for some reason
@@ -162,14 +171,90 @@ class XbmcBackup:
                 if(not shouldContinue):
                     return
 
+            utils.log(utils.getString(30051))
+            allFiles = []
+            fileManager = FileManager(self.xbmc_vfs)
+         
+            #go through each of the user selected items and write them to the backup store
+            if(utils.getSetting('backup_addons') == 'true'):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/addons'))
+                fileManager.excludeFile(xbmc.translatePath('special://home/addons/packages'))
+                fileManager.walkTree(xbmc.translatePath('special://home/addons'))
+
+            fileManager.addFile("-" + xbmc.translatePath('special://home/userdata'))
+
+            if(utils.getSetting('backup_addon_data') == 'true'):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/addon_data'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/addon_data'))
+
+            if(utils.getSetting('backup_database') == 'true'):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/Database'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/Database'))
+        
+            if(utils.getSetting("backup_playlists") == 'true'):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/playlists'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/playlists'))
+
+            if(utils.getSetting('backup_profiles') == 'true'):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/profiles'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/profiles'))
+            
+            if(utils.getSetting("backup_thumbnails") == "true"):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/Thumbnails'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/Thumbnails'))
+ 
+            if(utils.getSetting("backup_config") == "true"):
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/keymaps'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/keymaps'))
+                
+                fileManager.addFile("-" + xbmc.translatePath('special://home/userdata/peripheral_data'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/peripheral_data'))
+            
+                fileManager.addFile('-' + xbmc.translatePath('special://home/userdata/library'))
+                fileManager.walkTree(xbmc.translatePath('special://home/userdata/library'))
+            
+                #this part is an oddity
+                dirs,configFiles = self.xbmc_vfs.listdir(xbmc.translatePath('special://home/userdata/'))
+                for aFile in configFiles:
+                    if(aFile.endswith(".xml")):
+                        fileManager.addFile(xbmc.translatePath('special://home/userdata/') + aFile)
+
+            #add to array
+            self.filesTotal = fileManager.size()
+            allFiles.append({"source":self.xbmc_vfs.root_path,"dest":self.remote_vfs.root_path,"files":fileManager.getFiles()})
+
             orig_base_path = self.remote_vfs.root_path
             
+            #check if there are custom directories
+            if(utils.getSetting('custom_dir_1_enable') == 'true' and utils.getSetting('backup_custom_dir_1') != ''):
+
+                #create a special remote path with hash                
+                self.xbmc_vfs.set_root(utils.getSetting('backup_custom_dir_1'))
+                fileManager.addFile("-custom_" + self._createCRC(self.xbmc_vfs.root_path))
+
+                #walk the directory
+                fileManager.walkTree(self.xbmc_vfs.root_path)
+                self.filesTotal = self.filesTotal + fileManager.size()
+                allFiles.append({"source":self.xbmc_vfs.root_path,"dest":self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path),"files":fileManager.getFiles()})
+
+            if(utils.getSetting('custom_dir_2_enable') == 'true' and utils.getSetting('backup_custom_dir_2') != ''):
+
+                #create a special remote path with hash                
+                self.xbmc_vfs.set_root(utils.getSetting('backup_custom_dir_2'))
+                fileManager.addFile("-custom_" + self._createCRC(self.xbmc_vfs.root_path))
+
+                #walk the directory
+                fileManager.walkTree(self.xbmc_vfs.root_path)
+                self.filesTotal = self.filesTotal + fileManager.size()
+                allFiles.append({"source":self.xbmc_vfs.root_path,"dest":self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path),"files":fileManager.getFiles()})
+
+
             #backup all the files
             self.filesLeft = self.filesTotal
             for fileGroup in allFiles:
-                self.xbmc_vfs.set_root(xbmc.translatePath(fileGroup['source']))
+                self.xbmc_vfs.set_root(fileGroup['source'])
-                self.remote_vfs.set_root(fileGroup['dest'] + fileGroup['name'])
+                self.remote_vfs.set_root(fileGroup['dest'])
-                filesCopied = self._copyFiles(fileGroup['files'],self.xbmc_vfs,self.remote_vfs)
+                filesCopied = self.backupFiles(fileGroup['files'],self.xbmc_vfs,self.remote_vfs)
                 
                 if(not filesCopied):
                     utils.showNotification(utils.getString(30092))
@@ -180,8 +265,6 @@ class XbmcBackup:
             self.remote_vfs.set_root(orig_base_path)
 
             if(utils.getSetting("compress_backups") == 'true'):
-                fileManager = FileManager(self.xbmc_vfs)
-                
                 #send the zip file to the real remote vfs
                 zip_name = self.remote_vfs.root_path[:-1] + ".zip"
                 self.remote_vfs.cleanup()
@@ -193,7 +276,7 @@ class XbmcBackup:
                
                 self.remote_vfs = self.saved_remote_vfs
                 self.progressBar.updateProgress(98, utils.getString(30088))
-                fileCopied = self._copyFiles(fileManager.getFiles(),self.xbmc_vfs, self.remote_vfs)
+                fileCopied = self.backupFiles(fileManager.getFiles(),self.xbmc_vfs, self.remote_vfs)
                 
                 if(not fileCopied):
                     #zip archive copy filed, inform the user
@@ -205,13 +288,7 @@ class XbmcBackup:
             #remove old backups
             self._rotateBackups()
 
-            #close any files
+        elif (mode == self.Restore):
-            self._closeVFS()
-
-    def restore(self,progressOverride=False,selectedSets=None):
-        shouldContinue = self._setupVFS(self.Restore, progressOverride)
-        
-        if(shouldContinue):
             utils.log(utils.getString(30023) + " - " + utils.getString(30017))
 
             #catch for if the restore point is actually a zip file
@@ -227,7 +304,7 @@ class XbmcBackup:
                     zipFile = []
                     zipFile.append(self.remote_base_path + self.restore_point)
                
-                    self._copyFiles(zipFile,self.remote_vfs, self.xbmc_vfs)
+                    self.backupFiles(zipFile,self.remote_vfs, self.xbmc_vfs)
                 else:
                     utils.log("zip file exists already")
                 
@@ -255,8 +332,7 @@ class XbmcBackup:
                 xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30045),self.remote_vfs.root_path)
                 return
 
-            valFile = self._checkValidationFile(self.remote_vfs.root_path)
+            if(not self._checkValidationFile(self.remote_vfs.root_path)):
-            if(valFile == None):
                 #don't continue
                 return
 
@@ -264,55 +340,104 @@ class XbmcBackup:
             allFiles = []
             fileManager = FileManager(self.remote_vfs)
          
-            #check for the existance of an advancedsettings file
+            #go through each of the user selected items and write them to the backup store
-            if(self.remote_vfs.exists(self.remote_vfs.root_path + "config/advancedsettings.xml") and not self.skip_advanced):
-                #let the user know there is an advanced settings file present
-                restartXbmc = xbmcgui.Dialog().yesno(utils.getString(30038),utils.getString(30039),utils.getString(30040), utils.getString(30041))
 
-                if(restartXbmc):
+            if(utils.getSetting("backup_config") == "true"):
-                    #add only this file to the file list
+                #check for the existance of an advancedsettings file
-                    fileManager.addFile(self.remote_vfs.root_path + "config/advancedsettings.xml")
+                if(self.remote_vfs.exists(self.remote_vfs.root_path + "userdata/advancedsettings.xml") and not self.skip_advanced):
-                    self._copyFiles(fileManager.getFiles(),self.remote_vfs,self.xbmc_vfs)
+                    #let the user know there is an advanced settings file present
+                    restartXbmc = xbmcgui.Dialog().yesno(utils.getString(30038),utils.getString(30039),utils.getString(30040), utils.getString(30041))
 
-                    #let the service know to resume this backup on startup
+                    if(restartXbmc):
-                    self._createResumeBackupFile()
+                        #add only this file to the file list
+                        fileManager.addFile(self.remote_vfs.root_path + "userdata/advancedsettings.xml")
+                        self.backupFiles(fileManager.getFiles(),self.remote_vfs,self.xbmc_vfs)
 
-                    #do not continue running
+                        #let the service know to resume this backup on startup
-                    xbmcgui.Dialog().ok(utils.getString(30077),utils.getString(30078)) 
+                        self._createResumeBackupFile()
-                    return
 
-            #use a multiselect dialog to select sets to restore
+                        #do not continue running
-            restoreSets = [n['name'] for n in valFile['directories']]
+                        xbmcgui.Dialog().ok(utils.getString(30077),utils.getString(30078))
                         
-            #if passed in list, skip selection
+                        return
-            if(selectedSets == None):
-                selectedSets = xbmcgui.Dialog().multiselect(utils.getString(30131),restoreSets)
-            else:
-                selectedSets = [restoreSets.index(n) for n in selectedSets if n in restoreSets] #if set name not found just skip it
                 
-            if(selectedSets != None):
+                fileManager.addFile('-' + self.remote_vfs.root_path + 'userdata/keymaps')
-                #go through each of the directories in the backup and write them to the correct location
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/keymaps")
-                for index in selectedSets:
                 
-                    #add this directory
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/peripheral_data")
-                    aDir = valFile['directories'][index]
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/peripheral_data")
             
-                    self.xbmc_vfs.set_root(xbmc.translatePath(aDir['path']))
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/library")
-                    if(self.remote_vfs.exists(self.remote_vfs.root_path + aDir['name'] + '/')):
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/library")
-                        #walk the directory
-                        fileManager.walkTree(self.remote_vfs.root_path + aDir['name'] + '/')
-                        self.filesTotal = self.filesTotal + fileManager.size()
-                        allFiles.append({"source":self.remote_vfs.root_path + aDir['name'],"dest":self.xbmc_vfs.root_path,"files":fileManager.getFiles()}) 
-                    else:
-                        utils.log("error path not found: " + self.remote_vfs.root_path + aDir['name'])
-                        xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30045),self.remote_vfs.root_path + aDir['name'])
             
-                #restore all the files
+                #this part is an oddity
-                self.filesLeft = self.filesTotal
+                dirs,configFiles = self.remote_vfs.listdir(self.remote_vfs.root_path + "userdata/")
-                for fileGroup in allFiles:
+                for aFile in configFiles:
-                    self.remote_vfs.set_root(fileGroup['source'])
+                    if(aFile.endswith(".xml")):
-                    self.xbmc_vfs.set_root(fileGroup['dest'])
+                        fileManager.addFile(self.remote_vfs.root_path + "userdata/" + aFile)
-                    self._copyFiles(fileGroup['files'],self.remote_vfs,self.xbmc_vfs)
+
+            if(utils.getSetting('backup_addons') == 'true'):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "addons")
+                fileManager.walkTree(self.remote_vfs.root_path + "addons")
+
+            self.xbmc_vfs.mkdir(xbmc.translatePath('special://home/userdata'))
+
+            if(utils.getSetting('backup_addon_data') == 'true'):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/addon_data")
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/addon_data")
+
+            if(utils.getSetting('backup_database') == 'true'):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/Database")
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/Database")
+        
+            if(utils.getSetting("backup_playlists") == 'true'):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/playlists")
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/playlists")
+
+            if(utils.getSetting('backup_profiles') == 'true'):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/profiles")
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/profiles")
+                
+            if(utils.getSetting("backup_thumbnails") == "true"):
+                fileManager.addFile('-' + self.remote_vfs.root_path + "userdata/Thumbnails")
+                fileManager.walkTree(self.remote_vfs.root_path + "userdata/Thumbnails")
+
+            #add to array
+            self.filesTotal = fileManager.size()
+            allFiles.append({"source":self.remote_vfs.root_path,"dest":self.xbmc_vfs.root_path,"files":fileManager.getFiles()})    
+
+            #check if there are custom directories
+            if(utils.getSetting('custom_dir_1_enable') == 'true' and utils.getSetting('backup_custom_dir_1') != ''):
+
+                self.xbmc_vfs.set_root(utils.getSetting('backup_custom_dir_1'))
+                if(self.remote_vfs.exists(self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path) + "/")):
+                    #index files to restore
+                    fileManager.walkTree(self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path))
+                    self.filesTotal = self.filesTotal + fileManager.size()
+                    allFiles.append({"source":self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path),"dest":self.xbmc_vfs.root_path,"files":fileManager.getFiles()})
+                else:
+                    utils.log("error path not found: " + self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path))
+                    xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30045),self.remote_vfs.root_path + "custom_" + self._createCRC(utils.getSetting('backup_custom_dir_1')))
+
+            if(utils.getSetting('custom_dir_2_enable') == 'true' and utils.getSetting('backup_custom_dir_2') != ''):
+
+                self.xbmc_vfs.set_root(utils.getSetting('backup_custom_dir_2'))
+                if(self.remote_vfs.exists(self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path) + "/")):
+                    #index files to restore
+                    fileManager.walkTree(self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path))
+                    self.filesTotal = self.filesTotal + fileManager.size()
+                    allFiles.append({"source":self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path),"dest":self.xbmc_vfs.root_path,"files":fileManager.getFiles()})
+                else:
+                    utils.log("error path not found: " + self.remote_vfs.root_path + "custom_" + self._createCRC(self.xbmc_vfs.root_path))
+                    xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30045),self.remote_vfs.root_path + "custom_" + self._createCRC(utils.getSetting('backup_custom_dir_2')))
+
+
+            #restore all the files
+            self.filesLeft = self.filesTotal
+            for fileGroup in allFiles:
+                self.remote_vfs.set_root(fileGroup['source'])
+                self.xbmc_vfs.set_root(fileGroup['dest'])
+                self.backupFiles(fileGroup['files'],self.remote_vfs,self.xbmc_vfs)
 
             self.progressBar.updateProgress(99,"Clean up operations .....")
 
@@ -321,75 +446,26 @@ class XbmcBackup:
                 self.xbmc_vfs.rmfile(xbmc.translatePath("special://temp/" + self.restore_point))
                 self.xbmc_vfs.rmdir(self.remote_vfs.root_path)
 
-            
+            if(utils.getSetting("backup_config") == "true"):
-            #update the guisettings information (or what we can from it)
+                #update the guisettings information (or what we can from it)
-            gui_settings = GuiSettingsManager()
+                gui_settings = GuiSettingsManager('special://home/userdata/guisettings.xml')
-            gui_settings.run()
+                gui_settings.run()
 
             #call update addons to refresh everything
             xbmc.executebuiltin('UpdateLocalAddons')
 
-    def _setupVFS(self,mode=-1,progressOverride=False):
-        #set windows setting to true
-        window = xbmcgui.Window(10000)
-        window.setProperty(utils.__addon_id__ + ".running","true")
-        
-        #append backup folder name
-        progressBarTitle = utils.getString(30010) + " - "
-        if(mode == self.Backup and self.remote_vfs.root_path != ''):
-            if(utils.getSetting("compress_backups") == 'true'):
-                #delete old temp file
-                if(self.xbmc_vfs.exists(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
-                    if(not self.xbmc_vfs.rmfile(xbmc.translatePath('special://temp/xbmc_backup_temp.zip'))):
-                        #we had some kind of error deleting the old file
-                        xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30096),utils.getString(30097))
-                        return False
-                    
-                #save the remote file system and use the zip vfs
-                self.saved_remote_vfs = self.remote_vfs
-                self.remote_vfs = ZipFileSystem(xbmc.translatePath("special://temp/xbmc_backup_temp.zip"),"w")
-                
-            self.remote_vfs.set_root(self.remote_vfs.root_path + time.strftime("%Y%m%d%H%M") + "/")
-            progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30016)
-        elif(mode == self.Restore and self.restore_point != None and self.remote_vfs.root_path != ''):
-            if(self.restore_point.split('.')[-1] != 'zip'):
-                self.remote_vfs.set_root(self.remote_vfs.root_path + self.restore_point + "/")
-            progressBarTitle = progressBarTitle + utils.getString(30023) + ": " + utils.getString(30017)
-        else:
-            #kill the program here
-            self.remote_vfs = None
-            return False
-
-        utils.log(utils.getString(30047) + ": " + self.xbmc_vfs.root_path)
-        utils.log(utils.getString(30048) + ": " + self.remote_vfs.root_path)
-
-        
-        #setup the progress bar
-        self.progressBar = BackupProgressBar(progressOverride)
-        self.progressBar.create(progressBarTitle,utils.getString(30049) + "......")
-
-        #if we made it this far we're good
-        return True
-
-    def _closeVFS(self):
         self.xbmc_vfs.cleanup()
         self.remote_vfs.cleanup()
         self.progressBar.close()
 
         #reset the window setting
-        window = xbmcgui.Window(10000)
         window.setProperty(utils.__addon_id__ + ".running","")
 
-    def _copyFiles(self,fileList,source,dest):
+    def backupFiles(self,fileList,source,dest):
         result = True
         
+        utils.log("Writing files to: " + dest.root_path)
         utils.log("Source: " + source.root_path)
-        utils.log("Desintation: " + dest.root_path)
-        
-        #make sure the dest folder exists - can cause write errors if the full path doesn't exist
-        if(not dest.exists(dest.root_path)):
-            dest.mkdir(dest.root_path)
-        
         for aFile in fileList:
             if(not self.progressBar.checkCancel()):
                 utils.log('Writing file: ' + aFile,xbmc.LOGDEBUG)
@@ -398,15 +474,13 @@ class XbmcBackup:
                     dest.mkdir(dest.root_path + aFile[len(source.root_path) + 1:])
                 else:
                     self._updateProgress()
-                    
                     wroteFile = True
-                    destFile = dest.root_path + aFile[len(source.root_path):]
                     if(isinstance(source,DropboxFileSystem) or isinstance(source,GoogleDriveFilesystem)):
                         #if copying from cloud storage we need the file handle, use get_file
-                        wroteFile = source.get_file(aFile,destFile)
+                        wroteFile = source.get_file(aFile,dest.root_path + aFile[len(source.root_path):])
                     else:
                         #copy using normal method
-                        wroteFile = dest.put(aFile,destFile)
+                        wroteFile = dest.put(aFile,dest.root_path + aFile[len(source.root_path):])
                     
                     #if result is still true but this file failed
                     if(not wroteFile and result):
@@ -415,29 +489,21 @@ class XbmcBackup:
                         
         return result
 
-    def _addBackupDir(self,folder_name,root_path,dirList):
+    def _createCRC(self,string):
-        utils.log('Backup set: ' + folder_name)
+        #create hash from string
-        fileManager = FileManager(self.xbmc_vfs)
+        string = string.lower()        
+        bytes = bytearray(string.encode())
+        crc = 0xffffffff;
+        for b in bytes:
+            crc = crc ^ (b << 24)          
+            for i in range(8):
+                if (crc & 0x80000000 ):                 
+                    crc = (crc << 1) ^ 0x04C11DB7                
+                else:
+                    crc = crc << 1;                        
+                    crc = crc & 0xFFFFFFFF
         
-        self.xbmc_vfs.set_root(xbmc.translatePath(root_path))
+        return '%08x' % crc
-        for aDir in dirList:
-            fileManager.addDir(aDir)
-
-        #walk all the root trees
-        fileManager.walk()
-        #update total files
-        self.filesTotal = self.filesTotal + fileManager.size()
-        
-        return {"name":folder_name,"source":root_path,"dest":self.remote_vfs.root_path,"files":fileManager.getFiles()}
-
-    def _dateFormat(self,dirName):
-        #create date_time object from foldername YYYYMMDDHHmm
-        date_time = datetime(int(dirName[0:4]),int(dirName[4:6]),int(dirName[6:8]),int(dirName[8:10]),int(dirName[10:12]))
-        
-        #format the string based on region settings
-        result = utils.getRegionalTimestamp(date_time, ['dateshort','time'])
-        
-        return result
 
     def _updateProgress(self,message=None):
         self.filesLeft = self.filesLeft - 1
@@ -448,7 +514,7 @@ class XbmcBackup:
         
         if(total_backups > 0):
             #get a list of valid backup folders
-            dirs = self.listBackups(reverse=False)
+            dirs = self.listBackups()
             
             if(len(dirs) > total_backups):
                 #remove backups to equal total wanted
@@ -468,16 +534,9 @@ class XbmcBackup:
                         
                     remove_num = remove_num + 1
 
-    def _createValidationFile(self,dirList):
+    def _createValidationFile(self):
-        valInfo = {"name":"XBMC Backup Validation File","xbmc_version":xbmc.getInfoLabel('System.BuildVersion'),"type":0}
-        valDirs = []
-        
-        for aDir in dirList:
-            valDirs.append({"name":aDir['name'],"path":aDir['source']})
-        valInfo['directories'] = valDirs
-        
         vFile = xbmcvfs.File(xbmc.translatePath(utils.data_dir() + "xbmcbackup.val"),'w')
-        vFile.write(json.dumps(valInfo))
+        vFile.write(json.dumps({"name":"XBMC Backup Validation File","xbmc_version":xbmc.getInfoLabel('System.BuildVersion')}))
         vFile.write("")
         vFile.close()
 
@@ -497,7 +556,7 @@ class XbmcBackup:
         return success
 
     def _checkValidationFile(self,path):
-        result = None
+        result = False
         
         #copy the file and open it
         self.xbmc_vfs.put(path + "xbmcbackup.val",xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"))
@@ -510,17 +569,16 @@ class XbmcBackup:
         xbmcvfs.delete(xbmc.translatePath(utils.data_dir() + "xbmcbackup_restore.val"))
 
         try:
-            result = json.loads(jsonString)
+            json_dict = json.loads(jsonString)
 
-            if(xbmc.getInfoLabel('System.BuildVersion') != result['xbmc_version']):
+            if(xbmc.getInfoLabel('System.BuildVersion') == json_dict['xbmc_version']):
-                shouldContinue = xbmcgui.Dialog().yesno(utils.getString(30085),utils.getString(30086),utils.getString(30044))
+                result = True
-
+            else:
-                if(not shouldContinue):
+                result = xbmcgui.Dialog().yesno(utils.getString(30085),utils.getString(30086),utils.getString(30044))
-                    result = None
                 
         except ValueError:
             #may fail on older archives
-            result = None
+            result = True
 
         return result
 
@@ -529,69 +587,46 @@ class XbmcBackup:
         rFile.write(self.restore_point)
         rFile.close()
 
-    def _readBackupConfig(self,aFile):
-        jFile = xbmcvfs.File(xbmc.translatePath(aFile),'r')
-        jsonString = jFile.read()
-        jFile.close()
-        return json.loads(jsonString)
-
 class FileManager:
     not_dir = ['.zip','.xsp','.rar']
     exclude_dir = []
-    root_dirs = []
     
     def __init__(self,vfs):
         self.vfs = vfs
         self.fileArray = []
-        self.exclude_dir = []
-        self.root_dirs = []
 
-    def walk(self):
+    def walkTree(self,directory):
         
-        for aDir in self.root_dirs:
+        if(directory[-1:] == '/'):
-            self.addFile('-' + xbmc.translatePath(aDir['path']))
-            self.walkTree(xbmc.translatePath(aDir['path']),aDir['recurse'])
-
-    def walkTree(self,directory,recurse=True):
-        utils.log('walking ' + directory + ', recurse: ' + str(recurse))
-        if(directory[-1:] == '/' or directory[-1:] == '\\'):
             directory = directory[:-1]
        
-        if(self.vfs.exists(directory + os.path.sep)):
+        if(self.vfs.exists(directory + "/")):
             dirs,files = self.vfs.listdir(directory)
         
-            if(recurse):
+            #create all the subdirs first
-                #create all the subdirs first
+            for aDir in dirs:
-                for aDir in dirs:
+                dirPath = xbmc.validatePath(xbmc.translatePath(directory + "/" + aDir))
-                    dirPath = xbmc.validatePath(xbmc.translatePath(directory + os.path.sep + aDir))
+                file_ext = aDir.split('.')[-1]
-                    file_ext = aDir.split('.')[-1]
 
-                    #check if directory is excluded
+                if(not dirPath in self.exclude_dir):
-                    if(not any(dirPath.startswith(exDir) for exDir in self.exclude_dir)):
                     
-                        self.addFile("-" + dirPath)
+                    self.addFile("-" + dirPath)
 
-                        #catch for "non directory" type files
+                    #catch for "non directory" type files
-                        shouldWalk = True
+                    shouldWalk = True
 
-                        for s in file_ext:
+                    for s in file_ext:
-                            if(s in self.not_dir):
+                        if(s in self.not_dir):
-                                shouldWalk = False
+                            shouldWalk = False
                 
-                        if(shouldWalk):
+                    if(shouldWalk):
-                            self.walkTree(dirPath)  
+                        self.walkTree(dirPath)  
             
             #copy all the files
             for aFile in files:
-                filePath = xbmc.translatePath(directory + os.path.sep + aFile)
+                filePath = xbmc.translatePath(directory + "/" + aFile)
                 self.addFile(filePath)
                     
-    def addDir(self,dirMeta):
-        if(dirMeta['type'] == 'include'):
-            self.root_dirs.append({'path':dirMeta['path'],'recurse':dirMeta['recurse']})
-        else:
-            self.excludeFile(xbmc.translatePath(dirMeta['path']))
-            
     def addFile(self,filename):
         try:
             filename = filename.decode('UTF-8')
@@ -608,20 +643,13 @@ class FileManager:
         except UnicodeDecodeError:
             filename = filename.decode('ISO-8859-2')
             
-        #remove trailing slash
-        if(filename[-1] == '/' or filename[-1] == '\\'):
-            filename = filename[:-1]
-        
         #write the full remote path name of this file
-        utils.log("Exclude File: " + filename)
+        utils.log("Exclude File: " + filename,xbmc.LOGDEBUG)
         self.exclude_dir.append(filename)
 
     def getFiles(self):
         result = self.fileArray
         self.fileArray = []
-        self.root_dirs = []
-        self.exclude_dir = []
-                                  
         return result
 
     def size(self):

resources/lib/dropbox/oauth.py

@@ -511,5 +511,9 @@ def _params_to_urlencoded(params):
             else:
                 return str(o).encode('utf-8')
 
-    utf8_params = {encode(k): encode(v) for k, v in six.iteritems(params)}
+    #fix for python 2.6
+    utf8_params = {}
+    for k,v in six.iteritems(params):
+        utf8_params[encode(k)] = encode(v)
+
     return url_encode(utf8_params)

resources/lib/dropbox/stone_serializers.py

@@ -237,11 +237,12 @@ class StoneToPythonPrimitiveSerializer(StoneSerializerBase):
     def encode_map(self, validator, value):
         validated_value = validator.validate(value)
 
-        return {
+        #fix for python 2.6
-            self.encode_sub(validator.key_validator, key):
+        result = {}
-                self.encode_sub(validator.value_validator, value) for
+        for key, value in validated_value.items():
-            key, value in validated_value.items()
+            result[self.encode_sub(validator.key_validator,key)] = self.encode_sub(validator.value_validator, value)
-        }
+
+        return result
 
     def encode_nullable(self, validator, value):
         if value is None:
@@ -830,11 +831,12 @@ def _decode_list(
     if not isinstance(obj, list):
         raise bv.ValidationError(
             'expected list, got %s' % bv.generic_type_name(obj))
-    return [
+
-        _json_compat_obj_decode_helper(
+    result = []
-            data_type.item_validator, item, alias_validators, strict,
+    for item in obj:
-            old_style, for_msgpack)
+        result.append(_json_compat_obj_decode_helper(data_type.item_validator, item, alias_validators, strict,old_style, for_msgpack))
-        for item in obj]
+    
+    return result
 
 
 def _decode_map(
@@ -846,15 +848,12 @@ def _decode_map(
     if not isinstance(obj, dict):
         raise bv.ValidationError(
             'expected dict, got %s' % bv.generic_type_name(obj))
-    return {
+
-        _json_compat_obj_decode_helper(
+    result = {}
-            data_type.key_validator, key, alias_validators, strict,
+    for key, value in obj.items():
-            old_style, for_msgpack):
+        result[_json_compat_obj_decode_helper(data_type.key_validator, key, alias_validators, strict,old_style, for_msgpack)] = _json_compat_obj_decode_helper(data_type.value_validator, value, alias_validators, strict,old_style, for_msgpack)
-        _json_compat_obj_decode_helper(
+
-            data_type.value_validator, value, alias_validators, strict,
+    return result
-            old_style, for_msgpack)
-        for key, value in obj.items()
-    }
 
 
 def _decode_nullable(

resources/lib/dropbox/stone_validators.py

@@ -422,10 +422,13 @@ class Map(Composite):
     def validate(self, val):
         if not isinstance(val, dict):
             raise ValidationError('%r is not a valid dict' % val)
-        return {
+
-            self.key_validator.validate(key):
+        #fix for python 2.6
-                self.value_validator.validate(value) for key, value in val.items()
+        result = {}
-        }
+        for key, value in val.items():
+            result[self.key_validator.validate(key)] = self.value_validator.validate(value)
+        
+        return result
 
 
 class Struct(Composite):

resources/lib/guisettings.py

@@ -6,68 +6,94 @@ import xbmc,xbmcvfs
 
 
 class GuiSettingsManager:
+    settingsFile = None
     doc = None
+    settings_allowed = list()
+    found_settings = list()
     
-    def __init__(self):
+    def __init__(self,settingsFile):
-        #first make a copy of the file
+        self._readFile(xbmc.translatePath(settingsFile))
-        xbmcvfs.copy(xbmc.translatePath('special://home/userdata/guisettings.xml'), xbmc.translatePath("special://home/userdata/guisettings.xml.restored"))
-        
-        #read in the copy
-        self._readFile(xbmc.translatePath('special://home/userdata/guisettings.xml.restored'))
     
     def run(self):
         #get a list of all the settings we can manipulate via json
         json_response = json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0", "id":1, "method":"Settings.GetSettings","params":{"level":"advanced"}}'))
         
         settings = json_response['result']['settings']
-        currentSettings = {}
            
         for aSetting in settings:
-            if('value' in aSetting):
+            self.settings_allowed.append(aSetting['id'])
-                currentSettings[aSetting['id']] = aSetting['value']
             
-        #parse the existing xml file and get all the settings we need to restore
+        #parse the existing xml file and get all the settings
-        restoreSettings = self.__parseNodes(self.doc.getElementsByTagName('setting'))
+        root_nodes = self.__parseNodes(self.doc.documentElement)
         
-        #get a list where the restore setting value != the current value
+        for aNode in root_nodes:
-        updateSettings = {k: v for k, v in restoreSettings.items() if (k in currentSettings and currentSettings[k] != v)}
+            secondary_list = self.__parseNodes(self.doc.getElementsByTagName(aNode.name)[0])
+            
+            for secondNode in secondary_list:
+                #if the node does not have children and is not default
+                if(not secondNode.hasChildren and not secondNode.isDefault):
+                    
+                    if(secondNode.json_name() in self.settings_allowed):
+                        self.found_settings.append(secondNode)
                     
         #go through all the found settings and update them
-        jsonObj = {"jsonrpc":"2.0","id":1,"method":"Settings.SetSettingValue","params":{"setting":"","value":""}}
+        for aSetting in self.found_settings:
-        for anId, aValue in updateSettings.items():
+            utils.log("updating: " + aSetting.json_name() + ", value: " + aSetting.value)
-            utils.log("updating: " + anId + ", value: " + str(aValue))
             
-            jsonObj['params']['setting'] = anId
+            #check for boolean and numeric values
-            jsonObj['params']['value'] = aValue
+            if(aSetting.value.isdigit() or (aSetting.value == 'true' or aSetting.value == 'false')):
+                xbmc.executeJSONRPC('{"jsonrpc":"2.0", "id":1, "method":"Settings.SetSettingValue","params":{"setting":"' + aSetting.json_name() + '","value":' + aSetting.value + '}}')
+            else:
+                xbmc.executeJSONRPC('{"jsonrpc":"2.0", "id":1, "method":"Settings.SetSettingValue","params":{"setting":"' + aSetting.json_name() + '","value":"' + utils.encode(aSetting.value) + '"}}')
                 
-            xbmc.executeJSONRPC(json.dumps(jsonObj))
+        #make a copy of the guisettings file to make user based restores easier
+        xbmcvfs.copy(self.settingsFile, xbmc.translatePath("special://home/userdata/guisettings.xml.restored"))
             
     def __parseNodes(self,nodeList):
-        result = {}
+        result = []
 
-        for node in nodeList:
+        for node in nodeList.childNodes:
-            nodeValue = ''
+            if(node.nodeType == self.doc.ELEMENT_NODE):
-            if(node.firstChild != None):
+                aSetting = SettingNode(node.nodeName)
-                nodeValue = node.firstChild.nodeValue
 
-            #check for numbers and booleans
+                #detect if there are any element nodes
-            if(nodeValue.isdigit()):
+                if(len(node.childNodes) > 0):
-                nodeValue = int(nodeValue)
+                    for child_node in node.childNodes:
-            elif(nodeValue == 'true'):
+                        if(child_node.nodeType == self.doc.ELEMENT_NODE):
-                nodeValue = True
+                            aSetting.hasChildren = True
-            elif(nodeValue == 'false'):
-                nodeValue = False
 
-            result[node.getAttribute('id')] = nodeValue
+                if(not aSetting.hasChildren and len(node.childNodes) > 0):
+                    aSetting.value = node.firstChild.nodeValue
                     
+                    if('default' not in node.attributes.keys()):
+                        aSetting.isDefault = False
+                        
+                aSetting.parent = node.parentNode.nodeName
+                
+                result.append(aSetting)
         return result
     
+    
     def _readFile(self,fileLoc):
         
         if(xbmcvfs.exists(fileLoc)):
             try:
                 self.doc = minidom.parse(fileLoc)
+                self.settingsFile = fileLoc
             except ExpatError:
                 utils.log("Can't read " + fileLoc)
                 
+class SettingNode:
+    name = ''
+    value = ''
+    hasChildren = False
+    isDefault = True
+    parent = ''
+    
+    def __init__(self,name):
+        self.name = name
+        
+    def json_name(self):
+        return self.parent + "." + self.name
+                
         

resources/lib/utils.py

@@ -14,11 +14,11 @@ def addon_dir():
 def openSettings():
     __Addon.openSettings()
 
-def log(message,loglevel=xbmc.LOGDEBUG):
+def log(message,loglevel=xbmc.LOGNOTICE):
     xbmc.log(encode(__addon_id__ + "-" + __Addon.getAddonInfo('version') +  ": " + message),level=loglevel)
 
 def showNotification(message):
-    xbmcgui.Dialog().notification(encode(getString(30010)),encode(message),time=4000,icon=xbmc.translatePath(__Addon.getAddonInfo('path') + "/resources/images/icon.png"))
+    xbmcgui.Dialog().notification(encode(getString(30010)),encode(message),time=4000,icon=xbmc.translatePath(__Addon.getAddonInfo('path') + "/icon.png"))
 
 def getSetting(name):
     return __Addon.getSetting(name)
@@ -29,14 +29,6 @@ def setSetting(name,value):
 def getString(string_id):
     return __Addon.getLocalizedString(string_id)
 
-def getRegionalTimestamp(date_time,dateformat=['dateshort']):
-    result = ''
-    
-    for aFormat in dateformat:
-        result = result + ("%s " % date_time.strftime(xbmc.getRegion(aFormat)))
-        
-    return result.strip()
-
 def encode(string):
     result = ''
 

resources/lib/vfs.py

@@ -1,12 +1,16 @@
 import utils as utils
+import tinyurl as tinyurl
 import xbmc
 import xbmcvfs
 import xbmcgui
 import zipfile
+import zlib
+import os
 import os.path
 import sys
 import dropbox
 from dropbox.files import WriteMode,CommitInfo,UploadSessionCursor
+from pydrive.drive import GoogleDrive
 from authorizers import DropboxAuthorizer,GoogleDriveAuthorizer
 
 class Vfs:
@@ -228,7 +232,7 @@ class DropboxFileSystem(Vfs):
                             self.client.files_upload_session_append_v2(f.read(self.MAX_CHUNK),upload_cursor)
                             upload_cursor.offset = f.tell()
                     
-                #if no errors we're good!   
+                 #if no errors we're good!   
                 return True
             except Exception as anError:
                 utils.log(str(anError))

resources/settings.xml

@@ -4,7 +4,6 @@
 		<setting id="compress_backups" type="bool" label="30087" default="false" />
 		<setting id="backup_rotation" type="number" label="30026" default="0" />
 		<setting id="progress_mode" type="enum" label="30022" lvalues="30082|30083|30084" default="0" />
-		<setting id="upgrade_notes" type="number" label="upgrade_notes" visible="false" default="1" />
 	</category>
 	<category id="backup_path" label="30048">
 		<setting id="remote_selection" type="enum" lvalues="30018|30019|30027|30098" default="0" label="30025"/>
@@ -14,22 +13,22 @@
 		<setting id="dropbox_secret" type="text" label="30029" visible="eq(-4,2)" default="" />
 		<setting id="google_drive_id" type="text" label="Client ID" visible="eq(-5,3)" default="" />
 		<setting id="google_drive_secret" type="text" label="Client Secret" visible="eq(-6,3)" default="" />
-		<setting id="auth_dropbox_button" type="action" label="30104" action="RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=authorize_cloud,provider=dropbox)" visible="eq(-7,2)"/>
+		<setting id="auth_dropbox_button" type="action" label="30104" action="RunScript(special://home/addons/script.xbmcbackup/authorize_cloud.py,type=dropbox)" visible="eq(-7,2)"/>
-		<setting id="auth_google_button" type="action" label="30104" action="RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=authorize_cloud,provider=google_drive)" visible="eq(-8,3)"/>
+		<setting id="auth_google_button" type="action" label="30104" action="RunScript(special://home/addons/script.xbmcbackup/authorize_cloud.py,type=google_drive)" visible="eq(-8,3)"/>
-		<setting id="remove_auth_button" type="action" label="30093" action="RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=remove_auth)" visible="gt(-9,1)"/>
+		<setting id="remove_auth_button" type="action" label="30093" action="RunScript(special://home/addons/script.xbmcbackup/remove_auth.py)" visible="gt(-9,1)"/>
 	</category>
 	<category id="selection" label="30012">
-		<setting id="backup_selection_type" type="enum" lvalues="30014|30015" default="0" label="30023" />
+		<setting id="backup_addons" type="bool" label="30030" default="true" />
-		<setting id="backup_addon_data" type="bool" label="30031" default="false" visible="eq(-1,0)"/>
+		<setting id="backup_addon_data" type="bool" label="30031" default="false" />
-		<setting id="backup_config" type="bool" label="30035" default="true" visible="eq(-2,0)"/>
+		<setting id="backup_database" type="bool" label="30032" default="true" />
-		<setting id="backup_database" type="bool" label="30032" default="true" visible="eq(-3,0)"/>
+		<setting id="backup_playlists" type="bool" label="30033" default="true" />
-		<setting id="backup_game_saves" type="bool" label="30133" default="false" visible="eq(-4,0)" />
+		<setting id="backup_profiles" type="bool" label="30080" default="false" />
-		<setting id="backup_playlists" type="bool" label="30033" default="true" visible="eq(-5,0)"/>
+		<setting id="backup_thumbnails" type="bool" label="30034" default="true" />
-		<setting id="backup_profiles" type="bool" label="30080" default="false" visible="eq(-6,0)"/>
+		<setting id="backup_config" type="bool" label="30035" default="true" />
-		<setting id="backup_thumbnails" type="bool" label="30034" default="true" visible="eq(-7,0)"/>
+		<setting id="custom_dir_1_enable" type="bool" label="30036" default="false" />
-		<setting id="backup_addons" type="bool" label="30030" default="true" visible="eq(-8,0)" />
+		<setting id="backup_custom_dir_1" type="folder" label="30018" default="" visible="eq(-1,true)"/>
-		<setting id="advanced_button" type="action" label="30125" visible="eq(-9,1)" action="RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=advanced_editor)" />
+		<setting id="custom_dir_2_enable" type="bool" label="30037" default="false" />
-		<setting id="advanced_defaults" type="action" label="30139" visible="eq(-10,1)" action="RunScript(special://home/addons/script.xbmcbackup/launcher.py,action=advanced_copy_config)" />
+		<setting id="backup_custom_dir_2" type="folder" label="30018" default="" visible="eq(-1,true)"/>
 	</category>
 	<category id="scheduling" label="30013">
 		<setting id="enable_scheduler" type="bool" label="30060" default="false" />

scheduler.py

@@ -1,14 +1,12 @@
 import xbmc
 import xbmcvfs
 import xbmcgui
-from datetime import datetime
+import datetime
 import time
 import resources.lib.utils as utils
 from resources.lib.croniter import croniter
 from resources.lib.backup import XbmcBackup
 
-UPGRADE_INT = 2  #to keep track of any upgrade notifications
-
 class BackupScheduler:
     monitor = None
     enabled = "false"
@@ -57,11 +55,6 @@ class BackupScheduler:
         
     def start(self):
 
-        #display upgrade messages if they exist
-        if(int(utils.getSetting('upgrade_notes')) < UPGRADE_INT):
-            xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30132))
-            utils.setSetting('upgrade_notes',str(UPGRADE_INT))
-
         #check if a backup should be resumed
         resumeRestore = self._resumeCheck()
 
@@ -70,7 +63,7 @@ class BackupScheduler:
             restore.selectRestore(self.restore_point)
             #skip the advanced settings check
             restore.skipAdvanced()
-            restore.restore()
+            restore.run(XbmcBackup.Restore)
         
         while(not self.monitor.abortRequested()):
             
@@ -105,9 +98,9 @@ class BackupScheduler:
         if(backup.remoteConfigured()):
             
             if(int(utils.getSetting('progress_mode')) in [0,1]):
-                backup.backup(True)
+                backup.run(XbmcBackup.Backup,True)
             else:
-                backup.backup(False)
+                backup.run(XbmcBackup.Backup,False)
             
             #check if this is a "one-off"
             if(int(utils.getSetting("schedule_interval")) == 0):
@@ -123,12 +116,12 @@ class BackupScheduler:
         #find the cron expression and get the next run time
         cron_exp = self.parseSchedule()
 
-        cron_ob = croniter(cron_exp,datetime.fromtimestamp(now))
+        cron_ob = croniter(cron_exp,datetime.datetime.fromtimestamp(now))
         new_run_time = cron_ob.get_next(float)
 
         if(new_run_time != self.next_run):
             self.next_run = new_run_time
-            utils.log("scheduler will run again on " + utils.getRegionalTimestamp(datetime.fromtimestamp(self.next_run),['dateshort','time']))
+            utils.log("scheduler will run again on " + datetime.datetime.fromtimestamp(self.next_run).strftime('%m-%d-%Y %H:%M'))
 
             #write the next time to a file
             fh = xbmcvfs.File(self.next_run_path, 'w')
@@ -137,7 +130,7 @@ class BackupScheduler:
 
             #only show when not in silent mode
             if(progress_mode != 2):                        
-                utils.showNotification(utils.getString(30081) + " " + utils.getRegionalTimestamp(datetime.fromtimestamp(self.next_run),['dateshort','time']))
+                utils.showNotification(utils.getString(30081) + " " + datetime.datetime.fromtimestamp(self.next_run).strftime('%m-%d-%Y %H:%M'))
                 
     def settingsChanged(self):
         current_enabled = utils.getSetting("enable_scheduler")