def preview(addon: xbmcaddon.Addon, timerid: int, player: 'xbmc.Player') -> None:
addon_dir = xbmcvfs.translatePath(addon.getAddonInfo('path'))
timer = Timer.init_from_settings(timerid)
if timer._is_playing_media_timer():
icon_file = os.path.join(
addon_dir, "resources", "assets", "icon.png")
xbmcgui.Dialog().notification(addon.getLocalizedString(
32027), addon.getLocalizedString(32110) % addon.getLocalizedString(32004 + timerid),
icon=icon_file)
if is_script(timer.s_path):
run_addon(timer.s_path)
elif timer.s_mediatype == PICTURE:
play_slideshow(timer.s_path, shuffle=timer.b_shuffle)
else:
playlist = build_playlist(path=timer.s_path, label=timer.s_label)
player.play(playlist)
else:
xbmcgui.Dialog().notification(addon.getLocalizedString(
32027), addon.getLocalizedString(32109))
class XbmcContext(Context):
def __init__(self, log, settings):
super(XbmcContext, self).__init__(log, settings)
self.addon = Addon()
def getLocalizedString(self, id):
return self.addon.getLocalizedString(id)
def getProfileDir(self):
profileDir = xbmc.translatePath(self.addon.getAddonInfo('profile'))
return profileDir
import xbmcvfs
from xbmcaddon import Addon
# get scraper object
AddonId = "metadata.media.passion.org"
Addon = Addon( AddonId )
# set variables
token = Addon.getSetting( "token" )
token64 = Addon.getSetting( "token64" )
login = Addon.getSetting( "username" )
passw = Addon.getSetting( "password" )
if settingId == "username":
heading = Addon.getLocalizedString( 30001 )
default = login
hidden = False
elif settingId == "password":
heading = Addon.getLocalizedString( 30002 )
default = passw
hidden = True
# condition pour mettre a jour la base
UpdateUserDB = False
# initialize Keyboard
kb = xbmc.Keyboard( default, heading, hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
steamExe = getSteamExe(addon)
cmd = [ahkExe, "%s" % steamExe, addon.getSetting('username'), addon.getSetting('password')]
subprocess.check_call(cmd)
def getSteamExe(addon):
steamFolder = addon.getSetting('steam_install_folder')
steamBinPath = os.path.join(steamFolder, STEAM_BINARY_NAME)
if not os.path.isfile(steamBinPath):
raise NotFoundError(addon.getLocalizedString(71004))
return steamBinPath
class NotFoundError(BaseException):
def __init__(self, msg):
self.msg = msg
if __name__ == "__main__":
addon = Addon(__scriptID__)
try:
launchSteamBpm(addon)
except CalledProcessError as e:
log('AHK return code: %d' % e.returncode)
msg = addon.getLocalizedString(72000 + e.returncode)
log(msg, LOGERROR)
dialog = Dialog()
dialog.ok(addon.getLocalizedString(71005), msg)
except BaseException as e:
log(str(e), LOGERROR)
dialog = Dialog()
dialog.ok(addon.getLocalizedString(71005), str(e))
if settingId == "username":
default = login
heading = 30003
hidden = False
elif settingId == "password":
default = passw
heading = 30004
hidden = True
# condition pour la compatibiliter, si aucun token n'est trouve cela veut surement dire que c'est une vielle version du scraper
hasToken = ( bool( Addon.getSetting( "token" ) ) == bool( Addon.getSetting( "tokenb64" ) ) == True )
# initialize Keyboard
kb = xbmc.Keyboard( default, Addon.getLocalizedString( heading ), hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
kb.doModal()
# si confirmation on continue les changement
if kb.isConfirmed():
# recup du text
text = kb.getText()
# si le text est pas vide et pas pareil que le default ou pas de token, on change
if text:# and ( text != default or not hasToken ):
# set our codes
if settingId == "username":
token = sha.new( text.lower() + passw ).hexdigest()
tokenb64 = b64encode( text )
else:
from xbmcaddon import Addon
# get scraper object
AddonId = "metadata.media.passion.org"
Addon = Addon( AddonId )
# set variables
token = Addon.getSetting( "token" )
token64 = Addon.getSetting( "token64" )
login = Addon.getSetting( "username" )
passw = Addon.getSetting( "password" )
if settingId == "username":
default = login
heading = Addon.getLocalizedString( 30003 )
hidden = False
elif settingId == "password":
default = passw
heading = Addon.getLocalizedString( 30004 )
hidden = True
# condition pour mettre a jour la base
UpdateUserDB = False
# initialize Keyboard
kb = xbmc.Keyboard( default, heading, hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
kb.doModal()
import xbmc
import xbmcvfs
from xbmcaddon import Addon
# get scraper object
AddonId = "metadata.passion.xbmc.org"
Addon = Addon(AddonId)
# set variables
token = Addon.getSetting("token" + settingMP)
token64 = Addon.getSetting("token64" + settingMP)
login = Addon.getSetting("username" + settingMP)
passw = Addon.getSetting("password" + settingMP)
if settingId == "username" + settingMP:
heading = Addon.getLocalizedString(30003)
default = login
hidden = False
elif settingId == "password" + settingMP:
heading = Addon.getLocalizedString(30004 + int(bool(settingMP)))
default = passw
hidden = True
# condition pour mettre a jour la base
UpdateUserDB = False
# initialize Keyboard
kb = xbmc.Keyboard(default, heading, hidden)
# optional hidden pass
kb.setHiddenInput(hidden)
# call Keyboard
# -*- coding: utf-8 -*-
import os
import sys
import xbmc
import xbmcgui
import xbmcvfs
from xbmcaddon import Addon
addon = Addon('plugin.video.telequebec')
addon_cache_basedir = os.path.join(
xbmc.translatePath(addon.getAddonInfo('path')).decode('utf-8'), ".cache")
if sys.argv[1].lower() == "full":
print "[" + addon.getAddonInfo('name') + "] deleting full cache"
for root, dirs, files in os.walk(addon_cache_basedir):
for file in files:
xbmcvfs.delete(os.path.join(root, file))
xbmcgui.Dialog().ok(addon.getAddonInfo('name'),
addon.getLocalizedString(32108),
addon.getLocalizedString(32109))
))
# recent tracks:
artwork.recent_1.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][0]['title'], recent_tracks['recently_played'][0]['artist']
))
artwork.recent_2.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][1]['title'], recent_tracks['recently_played'][1]['artist']
))
artwork.recent_3.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][2]['title'], recent_tracks['recently_played'][2]['artist']
))
sleep(5000)
log('Artwork closed')
del artwork
if __name__ == '__main__':
PLUGIN.run()
# empty previous thumbnails or create add-on data folder:
if os.path.exists(ADDON_DATA_FOLDER):
empty_directory(ADDON_DATA_FOLDER)
else:
os.makedirs(ADDON_DATA_FOLDER)
if sys.argv[0] == 'PLUGIN://{0}/'.format(ADDON_ID) and not ADDON.getSetting('username'):
executebuiltin('Notification("{0}", "{1}", 6000, "special://home/addons/{2}/icon.png")'
.format(ADDON.getLocalizedString(30000),
ADDON.getLocalizedString(32202),
ADDON_ID))
def reset_volume(addon: xbmcaddon.Addon) -> None:
vol_default = addon.getSettingInt("vol_default")
set_volume(vol_default)
xbmcgui.Dialog().notification(addon.getLocalizedString(
32027), addon.getLocalizedString(32112))
class KodiWrapper:
""" A wrapper around all Kodi functionality """
def __init__(self, routing=None):
""" Initialize the Kodi wrapper """
self.routing = None
if routing:
self.routing = routing
self._handle = self.routing.handle
self._url = self.routing.base_url
self._addon = Addon()
self._system_locale_works = None
self._addon_name = self._addon.getAddonInfo('name')
self._addon_id = self._addon.getAddonInfo('id')
self._global_debug_logging = self.get_global_setting(
'debug.showloginfo') # Returns a boolean
self._debug_logging = self.get_setting_as_bool('debug_logging')
self._cache_path = self.get_userdata_path() + 'cache/'
def show_listing(self,
title_items,
category=None,
sort='unsorted',
content=None,
cache=True):
""" Show a virtual directory in Kodi """
if content:
# content is one of: files, songs, artists, albums, movies, tvshows, episodes, musicvideos, videos, images, games
xbmcplugin.setContent(self._handle, content=content)
# Jump through hoops to get a stable breadcrumbs implementation
category_label = ''
if category:
if not content:
category_label = self._addon_name + ' / '
if self.kids_mode():
category_label += 'KIDS / '
if isinstance(category, int):
category_label += self.localize(category)
else:
category_label += category
elif not content:
category_label = self._addon_name
if self.kids_mode():
category_label += ' / KIDS'
xbmcplugin.setPluginCategory(handle=self._handle,
category=category_label)
# Add all sort methods to GUI (start with preferred)
xbmcplugin.addSortMethod(handle=self._handle,
sortMethod=SORT_METHODS[sort])
for key in sorted(SORT_METHODS):
if key != sort:
xbmcplugin.addSortMethod(handle=self._handle,
sortMethod=SORT_METHODS[key])
# Add the listings
listing = []
for title_item in title_items:
list_item = self._generate_listitem(title_item)
is_folder = bool(not title_item.is_playable and title_item.path)
url = title_item.path if title_item.path else None
listing.append((url, list_item, is_folder))
succeeded = xbmcplugin.addDirectoryItems(self._handle, listing,
len(listing))
xbmcplugin.endOfDirectory(self._handle, succeeded, cacheToDisc=cache)
@staticmethod
def _generate_listitem(title_item):
""" Generate a ListItem from a TitleItem """
from xbmcgui import ListItem
# Three options:
# - item is a virtual directory/folder (not playable, path)
# - item is a playable file (playable, path)
# - item is non-actionable item (not playable, no path)
is_folder = bool(not title_item.is_playable and title_item.path)
is_playable = bool(title_item.is_playable and title_item.path)
list_item = ListItem(label=title_item.title, path=title_item.path)
if title_item.prop_dict:
list_item.setProperties(title_item.prop_dict)
list_item.setProperty(key='IsPlayable',
value='true' if is_playable else 'false')
list_item.setIsFolder(is_folder)
if title_item.art_dict:
list_item.setArt(title_item.art_dict)
if title_item.info_dict:
# type is one of: video, music, pictures, game
list_item.setInfo(type='video', infoLabels=title_item.info_dict)
if title_item.stream_dict:
# type is one of: video, audio, subtitle
list_item.addStreamInfo('video', title_item.stream_dict)
if title_item.context_menu:
list_item.addContextMenuItems(title_item.context_menu)
return list_item
def play(self, title_item, license_key=None):
""" Play the passed TitleItem.
:type title_item: TitleItem
:type license_key: string
"""
play_item = self._generate_listitem(title_item)
play_item.setProperty('inputstreamaddon', 'inputstream.adaptive')
play_item.setProperty('inputstream.adaptive.max_bandwidth',
str(self.get_max_bandwidth() * 1000))
play_item.setProperty('network.bandwidth',
str(self.get_max_bandwidth() * 1000))
play_item.setProperty('inputstream.adaptive.manifest_type', 'mpd')
play_item.setMimeType('application/dash+xml')
play_item.setContentLookup(False)
if license_key is not None:
play_item.setProperty('inputstream.adaptive.license_type',
'com.widevine.alpha')
play_item.setProperty('inputstream.adaptive.license_key',
license_key)
if title_item.subtitles_path:
play_item.setSubtitles(title_item.subtitles_path)
# To support video playback directly from RunPlugin() we need to use xbmc.Player().play instead of
# setResolvedUrl that only works with PlayMedia() or with internal playable menu items
xbmcplugin.setResolvedUrl(self._handle, True, listitem=play_item)
if self.get_setting_as_bool('showsubtitles'):
while not xbmc.Player().isPlaying() and not xbmc.Monitor(
).abortRequested():
xbmc.sleep(100)
xbmc.Player().showSubtitles(True)
@staticmethod
def get_search_string(heading='', message=''):
""" Ask the user for a search string """
search_string = None
keyboard = xbmc.Keyboard(message, heading)
keyboard.doModal()
if keyboard.isConfirmed():
search_string = to_unicode(keyboard.getText())
return search_string
def show_ok_dialog(self, heading='', message=''):
""" Show Kodi's OK dialog """
from xbmcgui import Dialog
if not heading:
heading = self._addon.getAddonInfo('name')
return Dialog().ok(heading=heading, line1=message)
def show_notification(self,
heading='',
message='',
icon='info',
time=4000):
""" Show a Kodi notification """
from xbmcgui import Dialog
if not heading:
heading = self._addon.getAddonInfo('name')
Dialog().notification(heading=heading,
message=message,
icon=icon,
time=time)
def show_multiselect(self,
heading='',
options=None,
autoclose=0,
preselect=None,
use_details=False):
""" Show a Kodi multi-select dialog """
from xbmcgui import Dialog
if not heading:
heading = self._addon.getAddonInfo('name')
return Dialog().multiselect(heading=heading,
options=options,
autoclose=autoclose,
preselect=preselect,
useDetails=use_details)
def show_progress(self, heading='', message=''):
""" Show a Kodi progress dialog """
from xbmcgui import DialogProgress
if not heading:
heading = self._addon.getAddonInfo('name')
progress = DialogProgress()
progress.create(heading=heading, line1=message)
return progress
def show_progress_background(self, heading='', message=''):
""" Show a Kodi progress dialog """
from xbmcgui import DialogProgressBG
if not heading:
heading = self._addon.getAddonInfo('name')
progress = DialogProgressBG()
progress.create(heading=heading, message=message)
return progress
def set_locale(self):
""" Load the proper locale for date strings """
import locale
locale_lang = self.get_global_setting('locale.language').split('.')[-1]
try:
# NOTE: This only works if the platform supports the Kodi configured locale
locale.setlocale(locale.LC_ALL, locale_lang)
return True
except Exception as exc: # pylint: disable=broad-except
if locale_lang == 'en_gb':
return True
self.log("Your system does not support locale '{locale}': {error}",
LOG_DEBUG,
locale=locale_lang,
error=exc)
return False
def localize(self, string_id, **kwargs):
""" Return the translated string from the .po language files, optionally translating variables """
if kwargs:
import string
return string.Formatter().vformat(
self._addon.getLocalizedString(string_id), (),
SafeDict(**kwargs))
return self._addon.getLocalizedString(string_id)
def get_setting(self, setting_id, default=None):
""" Get an add-on setting """
value = to_unicode(self._addon.getSetting(setting_id))
if value == '' and default is not None:
return default
return value
def get_setting_as_bool(self, setting):
""" Get an add-on setting as a boolean value """
return self.get_setting(setting).lower() == "true"
def set_setting(self, setting_id, setting_value):
""" Set an add-on setting """
return self._addon.setSetting(setting_id, setting_value)
def open_settings(self):
""" Open the add-in settings window """
self._addon.openSettings()
@staticmethod
def get_global_setting(setting):
""" Get a Kodi setting """
import json
json_result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "Settings.GetSettingValue", "params": {"setting": "%s"}, "id": 1}'
% setting)
return json.loads(json_result).get('result', dict()).get('value')
def get_cache(self, key, ttl=None):
""" Get an item from the cache
:type key: list[str]
:type ttl: int
"""
import time
fullpath = self._cache_path + '.'.join(key)
if not self.check_if_path_exists(fullpath):
return None
if ttl and time.mktime(
time.localtime()) - self.stat_file(fullpath).st_mtime() > ttl:
return None
with self.open_file(fullpath, 'r') as fdesc:
try:
import json
value = json.load(fdesc)
self.log('Fetching {file} from cache', file=fullpath)
return value
except (ValueError, TypeError):
return None
def set_cache(self, key, data):
""" Store an item in the cache
:type key: list[str]
:type data: str
"""
if not self.check_if_path_exists(self._cache_path):
self.mkdirs(self._cache_path)
fullpath = self._cache_path + '.'.join(key)
with self.open_file(fullpath, 'w') as fdesc:
import json
self.log('Storing to cache as {file}', file=fullpath)
json.dump(data, fdesc)
def invalidate_cache(self, ttl=None):
""" Clear the cache """
if not self.check_if_path_exists(self._cache_path):
return
_, files = self.listdir(self._cache_path)
import time
now = time.mktime(time.localtime())
for filename in files:
fullpath = self._cache_path + filename
if ttl and now - self.stat_file(fullpath).st_mtime() < ttl:
continue
self.delete_file(fullpath)
def get_max_bandwidth(self):
""" Get the max bandwidth based on Kodi and add-on settings """
addon_max_bandwidth = int(self.get_setting('max_bandwidth', '0'))
global_max_bandwidth = int(
self.get_global_setting('network.bandwidth'))
if addon_max_bandwidth != 0 and global_max_bandwidth != 0:
return min(addon_max_bandwidth, global_max_bandwidth)
if addon_max_bandwidth != 0:
return addon_max_bandwidth
if global_max_bandwidth != 0:
return global_max_bandwidth
return 0
def get_proxies(self):
""" Return a usable proxies dictionary from Kodi proxy settings """
usehttpproxy = self.get_global_setting('network.usehttpproxy')
if usehttpproxy is not True:
return None
try:
httpproxytype = int(
self.get_global_setting('network.httpproxytype'))
except ValueError:
httpproxytype = 0
socks_supported = has_socks()
if httpproxytype != 0 and not socks_supported:
# Only open the dialog the first time (to avoid multiple popups)
if socks_supported is None:
self.show_ok_dialog('',
self.localize(30966)) # Requires PySocks
return None
proxy_types = ['http', 'socks4', 'socks4a', 'socks5', 'socks5h']
if 0 <= httpproxytype < 5:
httpproxyscheme = proxy_types[httpproxytype]
else:
httpproxyscheme = 'http'
httpproxyserver = self.get_global_setting('network.httpproxyserver')
httpproxyport = self.get_global_setting('network.httpproxyport')
httpproxyusername = self.get_global_setting(
'network.httpproxyusername')
httpproxypassword = self.get_global_setting(
'network.httpproxypassword')
if httpproxyserver and httpproxyport and httpproxyusername and httpproxypassword:
proxy_address = '%s://%s:%s@%s:%s' % (
httpproxyscheme, httpproxyusername, httpproxypassword,
httpproxyserver, httpproxyport)
elif httpproxyserver and httpproxyport and httpproxyusername:
proxy_address = '%s://%s@%s:%s' % (httpproxyscheme,
httpproxyusername,
httpproxyserver, httpproxyport)
elif httpproxyserver and httpproxyport:
proxy_address = '%s://%s:%s' % (httpproxyscheme, httpproxyserver,
httpproxyport)
elif httpproxyserver:
proxy_address = '%s://%s' % (httpproxyscheme, httpproxyserver)
else:
return None
return dict(http=proxy_address, https=proxy_address)
@staticmethod
def get_cond_visibility(condition):
""" Test a condition in XBMC """
return xbmc.getCondVisibility(condition)
def has_inputstream_adaptive(self):
""" Whether InputStream Adaptive is installed and enabled in add-on settings """
return self.get_setting(
'useinputstreamadaptive',
'true') == 'true' and xbmc.getCondVisibility(
'System.HasAddon(inputstream.adaptive)') == 1
def credentials_filled_in(self):
""" Whether the add-on has credentials filled in """
return bool(
self.get_setting('username') and self.get_setting('password'))
@staticmethod
def kodi_version():
""" Returns major Kodi version """
return int(xbmc.getInfoLabel('System.BuildVersion').split('.')[0])
def can_play_drm(self):
""" Whether this Kodi can do DRM using InputStream Adaptive """
return self.get_setting('usedrm',
'true') == 'true' and self.get_setting(
'useinputstreamadaptive',
'true') == 'true' and self.supports_drm()
def supports_drm(self):
""" Whether this Kodi version supports DRM decryption using InputStream Adaptive """
return self.kodi_version() > 17
def get_userdata_path(self):
""" Return the profile's userdata path """
return to_unicode(
xbmc.translatePath(self._addon.getAddonInfo('profile')))
def get_addon_path(self):
""" Return the profile's addon path """
return to_unicode(xbmc.translatePath(self._addon.getAddonInfo('path')))
def get_addon_info(self, key):
""" Return addon information """
return self._addon.getAddonInfo(key)
@staticmethod
def listdir(path):
""" Return all files in a directory (using xbmcvfs)"""
from xbmcvfs import listdir
return listdir(path)
def mkdir(self, path):
""" Create a directory (using xbmcvfs) """
from xbmcvfs import mkdir
self.log("Create directory '{path}'.", LOG_DEBUG, path=path)
return mkdir(path)
def mkdirs(self, path):
""" Create directory including parents (using xbmcvfs) """
from xbmcvfs import mkdirs
self.log("Recursively create directory '{path}'.",
LOG_DEBUG,
path=path)
return mkdirs(path)
@staticmethod
def check_if_path_exists(path):
""" Whether the path exists (using xbmcvfs)"""
from xbmcvfs import exists
return exists(path)
@staticmethod
@contextmanager
def open_file(path, flags='r'):
""" Open a file (using xbmcvfs) """
from xbmcvfs import File
fdesc = File(path, flags)
yield fdesc
fdesc.close()
@staticmethod
def stat_file(path):
""" Return information about a file (using xbmcvfs) """
from xbmcvfs import Stat
return Stat(path)
def delete_file(self, path):
""" Remove a file (using xbmcvfs) """
from xbmcvfs import delete
self.log("Delete file '{path}'.", LOG_DEBUG, path=path)
return delete(path)
def end_of_directory(self):
""" Close a virtual directory, required to avoid a waiting Kodi """
xbmcplugin.endOfDirectory(handle=self._handle,
succeeded=False,
updateListing=False,
cacheToDisc=False)
def log(self, message, log_level=LOG_INFO, **kwargs):
""" Log info messages to Kodi """
if not self._global_debug_logging and self._debug_logging and log_level in [
LOG_DEBUG, LOG_INFO
]:
# If Debug Logging is not enabled, Kodi filters everything up to NOTICE out
log_level = LOG_NOTICE
if kwargs:
import string
message = string.Formatter().vformat(message, (),
SafeDict(**kwargs))
message = '[{addon}] {message}'.format(addon=self._addon_id,
message=message)
xbmc.log(msg=from_unicode(message), level=log_level)
def kids_mode(self):
""" Returns if kids zone is active """
if self.get_setting_as_bool('force_kids_zone'):
return True
if self.routing and self.routing.path.startswith('/kids'):
return True
return False
# recent tracks:
artwork.recent_1.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][0]['title'],
recent_tracks['recently_played'][0]['artist']))
artwork.recent_2.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][1]['title'],
recent_tracks['recently_played'][1]['artist']))
artwork.recent_3.setLabel('- [B]{0}[/B] by {1}'.format(
recent_tracks['recently_played'][2]['title'],
recent_tracks['recently_played'][2]['artist']))
sleep(5000)
log('Artwork closed')
del artwork
if __name__ == '__main__':
PLUGIN.run()
# empty previous thumbnails or create add-on data folder:
if os.path.exists(ADDON_DATA_FOLDER):
empty_directory(ADDON_DATA_FOLDER)
else:
os.makedirs(ADDON_DATA_FOLDER)
if sys.argv[0] == 'PLUGIN://{0}/'.format(
ADDON_ID) and not ADDON.getSetting('username'):
executebuiltin(
'Notification("{0}", "{1}", 6000, "special://home/addons/{2}/icon.png")'
.format(ADDON.getLocalizedString(30000),
ADDON.getLocalizedString(32202), ADDON_ID))
import xbmcvfs
from xbmcaddon import Addon
# get scraper object
AddonId = "metadata.passion.xbmc.org"
Addon = Addon( AddonId )
# set variables
token = Addon.getSetting( "token" + settingMP )
token64 = Addon.getSetting( "token64" + settingMP )
login = Addon.getSetting( "username" + settingMP )
passw = Addon.getSetting( "password" + settingMP )
if settingId == "username" + settingMP:
heading = Addon.getLocalizedString( 30003 )
default = login
hidden = False
elif settingId == "password" + settingMP:
heading = Addon.getLocalizedString( 30004 + int( bool( settingMP ) ) )
default = passw
hidden = True
# condition pour mettre a jour la base
UpdateUserDB = False
# initialize Keyboard
kb = xbmc.Keyboard( default, heading, hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
import os
import sys
import xbmc
import xbmcgui
import xbmcvfs
from xbmcaddon import Addon
addon = Addon('plugin.video.telequebec')
addon_cache_basedir = os.path.join(xbmc.translatePath(addon.getAddonInfo('path')),".cache")
if sys.argv[1].lower() == "full":
print "["+addon.getAddonInfo('name')+"] deleting full cache"
for root, dirs, files in os.walk(addon_cache_basedir):
for file in files:
xbmcvfs.delete(os.path.join(root,file))
xbmcgui.Dialog().ok(addon.getAddonInfo('name'), addon.getLocalizedString(32108),addon.getLocalizedString(32109))
# -*- coding: utf-8 -*-
import os
import sys
import xbmc
import xbmcgui
import xbmcvfs
from xbmcaddon import Addon
addon = Addon('plugin.infologique.TVAgo')
addon_cache_basedir = os.path.join(xbmc.translatePath(addon.getAddonInfo('path')).decode('utf-8'),".cache")
if sys.argv[1].lower() == "full":
print "["+addon.getAddonInfo('name')+"] deleting full cache"
for root, dirs, files in os.walk(addon_cache_basedir):
for file in files:
xbmcvfs.delete(os.path.join(root,file))
xbmcgui.Dialog().ok(addon.getAddonInfo('name'), addon.getLocalizedString(32108),addon.getLocalizedString(32109))
