def get_setting(setting_id, default=None):
''' Get an add-on setting '''
from xbmcaddon import Addon
value = to_unicode(Addon().getSetting(setting_id))
if value == '' and default is not None:
return default
return value
def __init__(self):
self.addon = None
self.addon_version = None
self.prop_cache = {}
self.addon_params = None
self.android_properties = {}
self.xbmc_python_version = None
self.xbmc_version = None
debug_rpc_res = self.json_rpc(method='Settings.GetSettingValue', params={'setting': 'debug.showloginfo'})
if debug_rpc_res is not None and debug_rpc_res.get('value', False) is True:
self.kodi_debug = True
else:
self.kodi_debug = False
try:
from xbmcaddon import Addon
_xbmc_python_version = Addon('xbmc.python').getAddonInfo('version')
self.log_debug('Detected xbmc.python version {}', _xbmc_python_version)
self.xbmc_python_version = LooseVersion(_xbmc_python_version)
except Exception as e:
self.log_notice('Could not detect xbmc.python version: {}', e)
pass
try:
_xbmc_version = getInfoLabel('System.BuildVersion')
self.log_debug('Detected xbmc version: {}', _xbmc_version)
self.xbmc_version = LooseVersion(_xbmc_version)
except Exception as e:
self.log_notice('Could not detect xbmc version version: {}', e)
pass
def get_addon(self): if self.addon is None: from xbmcaddon import Addon self.addon = Addon() return self.addon
def selectDevice():
import xbmc
from xbmcgui import Dialog
from xbmcaddon import Addon
ADDON = Addon("script.samsung.remote")
xbmc.executebuiltin('ActivateWindow(busydialog)')
tv_devices = sorted(getSamDevices().items())
choices = ["%s (%s) @ %s" % (v[0], v[1], k) for k, v in tv_devices] + ["Manual", "Cancel"]
xbmc.executebuiltin('Dialog.Close(busydialog,true)')
selected = Dialog().select("Select your Samsung device", choices)
device = None
if selected >= 0 and selected < len(tv_devices):
# auto and selected
device = tv_devices[selected]
ADDON.setSetting("autosam", "$LOCALIZE[13416]")
ADDON.setSetting("manualsam", "false")
ADDON.setSetting("tvmodel", device[1][1])
ADDON.setSetting("tvname", device[1][0])
ADDON.setSetting("tvip", device[0])
elif selected == len(tv_devices):
# manual
ADDON.setSetting("autosam", "$LOCALIZE[413]")
ADDON.setSetting("manualsam", "true")
xbmc.sleep(500)
xbmc.executebuiltin('Action(Down)')
def getSettings(self, id="repository.xbmc.builds"):
settings = {}
try:
from xbmcaddon import Addon
addon = Addon(id)
usetempdir = addon.getSetting("usetempdir") == "true"
browsedir = addon.getSetting("browsedir") == "true"
settings["downloadpath"] = (addon.getSetting("downloadpath"),
"")[browsedir]
if not usetempdir:
#browse for save dir
if not settings["downloadpath"] or not os.path.exists(
settings["downloadpath"]):
dpath = xbmc.translatePath(
self.get_browse_dialog(heading="Recordings folder"))
if dpath and os.path.exists(dpath):
settings["downloadpath"] = dpath
addon.setSetting("downloadpath",
settings["downloadpath"])
else:
settings["downloadpath"] = ""
settings["downloadinbackground"] = addon.getSetting(
"downloadinbackground") == "true"
settings["reportpercent"] = int(
"0|5|10|20|25|50|100".split("|")[int(
addon.getSetting("reportpercent"))])
PROFILE_PATH = xbmc.translatePath(addon.getAddonInfo("profile"))
settings["iddl_data"] = os.path.join(PROFILE_PATH, "iddl_data")
if not os.path.exists(settings["iddl_data"]):
os.makedirs(settings["iddl_data"])
except:
pass
return settings
def install_repo(self, repoName, repoURL):
"""
Install a repository in XBMC
-> will need XBMC restart in order to have the new Repo taken in account by XBMC
"""
continueInstall = True
dialogYesNo = xbmcgui.Dialog()
if dialogYesNo.yesno(repoName, Language(30100), Language(30101)):
if continueInstall:
ri = RepoInstaller()
newRepo = ri.download(repoURL)
print newRepo
if newRepo:
fp, ok = ri.install(newRepo)
print "---"
print fp, ok
xbmc.executebuiltin('UpdateLocalAddons')
xbmc.sleep(100)
xbmc.executebuiltin('UpdateAddonRepos')
xbmc.sleep(100)
try:
_N_ = Addon(os.path.basename(fp))
print "Addon %s Installed" % s_N_
ri.notification(_N_.getAddonInfo("name"),
Language(24065).encode("utf-8"), 5000,
_N_.getAddonInfo("icon"))
except:
xbmcgui.Dialog().ok(ADDON.getAddonInfo("name"),
Language(30007) + " : " + repoName,
Language(30010))
self._end_of_directory(True, update=False)
def convert_to_dash(manifest):
"""Convert a Netflix style manifest to MPEG-DASH manifest"""
from xbmcaddon import Addon
isa_version = Addon('inputstream.adaptive').getAddonInfo('version')
has_drm_streams = manifest['hasDrmStreams']
protection_info = _get_protection_info(manifest) if has_drm_streams else None
seconds = int(manifest['duration'] / 1000)
init_length = int(seconds / 2 * 12 + 20 * 1000)
duration = "PT" + str(seconds) + ".00S"
root = _mpd_manifest_root(duration)
period = ET.SubElement(root, 'Period', start='PT0S', duration=duration)
for video_track in manifest['video_tracks']:
_convert_video_track(video_track, period, init_length, protection_info, has_drm_streams)
common.fix_locale_languages(manifest['audio_tracks'])
common.fix_locale_languages(manifest['timedtexttracks'])
default_audio_language_index = _get_default_audio_language(manifest)
for index, audio_track in enumerate(manifest['audio_tracks']):
_convert_audio_track(audio_track, period, init_length, (index == default_audio_language_index), has_drm_streams)
default_subtitle_language_index = _get_default_subtitle_language(manifest)
for index, text_track in enumerate(manifest['timedtexttracks']):
if text_track['isNoneTrack']:
continue
_convert_text_track(text_track, period, (index == default_subtitle_language_index), isa_version)
xml = ET.tostring(root, encoding='utf-8', method='xml')
if common.is_debug_verbose():
common.save_file('manifest.mpd', xml)
return xml.decode('utf-8').replace('\n', '').replace('\r', '').encode('utf-8')
def update_service():
# this read the settings
settings = tools.Settings()
# define the browser
browser = tools.Browser()
#Begin Service
if settings.service == 'true':
if settings.time_noti > 0:
settings.dialog.notification(settings.name_provider,
'Checking Online...', settings.icon,
settings.time_noti)
quality = Addon().getSetting('quality')
sort = Addon().getSetting('sort')
url_search = "%s/api/v2/list_movies.json?limit=50&quality=%s&sort_by=%s&order_by=desc" % (
settings.url_address, quality, sort.lower().replace(' ', '_'))
settings.log(url_search)
title = []
magnet = []
for page in range(settings.pages):
if settings.time_noti > 0:
settings.dialog.notification(
settings.name_provider,
'Checking Online, Page %s...' % str(page + 1),
settings.icon, settings.time_noti)
if browser.open(url_search):
data = json.loads(browser.content)
for movie in data['data']['movies']:
if movie.has_key('torrents'):
for torrent in movie['torrents']:
if torrent['quality'] in quality:
title.append(movie['title_long'])
magnet.append('magnet:?xt=urn:btih:%s' %
torrent['hash'])
if len(title) > 0:
tools.integration(filename=title,
magnet=magnet,
type_list='MOVIE',
folder=settings.movie_folder,
silence=True,
name_provider=settings.name_provider)
else:
settings.log('[%s] >>>>>>>%s<<<<<<<' %
(settings.name_provider_clean, browser.status))
settings.dialog.notification(settings.name_provider,
browser.status, settings.icon, 1000)
del settings
del browser
def get_video_url(page_url,
premium=False,
user="",
password="",
video_password=""):
import xbmc
from xbmcaddon import Addon
logger.info("(page_url='%s')" % page_url)
video_urls = []
if not page_url.startswith("http"):
page_url = "http://www.youtube.com/watch?v=%s" % page_url
logger.info(" page_url->'%s'" % page_url)
video_id = scrapertools.find_single_match(page_url,
'(?:v=|embed/)([A-z0-9_-]{11})')
inputstream = platformtools.install_inputstream()
# from core.support import dbg;dbg()
try:
__settings__ = Addon(name)
if inputstream:
__settings__.setSetting('kodion.video.quality.mpd', 'true')
else:
__settings__.setSetting('kodion.video.quality.mpd', 'false')
video_urls = [[
'con YouTube',
'plugin://plugin.video.youtube/play/?video_id=' + video_id
]]
except:
if filetools.exists(
xbmc.translatePath('special://profile/addon_data/' + name)):
if platformtools.dialog_yesno(config.get_localized_string(70784),
config.get_localized_string(70818)):
xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "id":1, "method": "Addons.SetAddonEnabled", "params": { "addonid": "'
+ name + '", "enabled": true }}')
else:
return [['', '']]
else:
xbmc.executebuiltin('InstallAddon(' + name + ')', wait=True)
try:
Addon(name)
except:
return [['', '']]
return get_video_url(page_url)
return video_urls
def run(self):
try:
play_sfx = False
# NB: xbmc.abortRequested not work correctly with threading.Thread
while not xbmc.abortRequested:
try:
self.getWindow()
if self.sprite != self.addon.getSetting("sprite"):
self.getMedias()
if not xbmc.getCondVisibility(
'Window.IsActive(Pointer.xml)'):
time.sleep(.3)
continue
pos = xbmcgui.getMousePosition()
if ((pos[0] - self.offsetx) == self.current_pos[0]) and (
pos[1] == self.current_pos[1]):
self.control.setImage(self.sprites["wait"])
if play_sfx:
if self.sprites["sfx"] and self.addon.getSetting(
"playsfx") == "true":
xbmc.playSFX(self.sprites["sfx"])
play_sfx = False
else:
play_sfx = True
if pos[0] < self.current_pos[0]:
self.control.setImage(self.sprites["left"])
else:
self.control.setImage(self.sprites["right"])
#start = "%i,%i" % self.current_pos
#end = "%i,%i" % ( pos[ 0 ]-self.offsetx, pos[ 1 ] )
##self.speed = str( self.current_pos[ 0 ] - pos[ 0 ] ).strip( "-" )
#self.control.setAnimations( [ ( 'conditional', 'condition=true effect=slide start=%s end=%s time=%s' % ( start, end, self.speed ) ) ] )
self.setAnimation(pos)
self.current_pos = (pos[0] - self.offsetx, pos[1])
#self.control.setPosition( *self.current_pos )
if xbmc.getCondVisibility(
"Window.IsActive(addonsettings)"):
self.reload_addon = True
elif self.reload_addon:
self.addon = Addon("script.mouse.tracker.service")
self.speed = self.addon.getSetting("speed").split(
".")[0]
self.reload_addon = False
except SystemExit:
break
except:
print_exc()
time.sleep(float(int(self.speed)) * 0.001)
except SystemExit:
pass
except:
print_exc()
def _inputstream_version(self):
''' Return the requested inputstream version '''
try:
addon = Addon(self.inputstream_addon)
except RuntimeError:
return None
return to_unicode(addon.getAddonInfo('version'))
def get_stream(url, order=0, page_type='', suborder=False, submenu=False):
print("url is: ")
print(url)
scraper = cfscrape.create_scraper()
if Addon().getSettingBool('enable_proxy') == True:
if Addon().getSettingInt('proxy_type') == 0:
proxy_type = 'http'
elif Addon().getSettingInt('proxy_type') == 1:
proxy_type = 'socks4'
elif Addon().getSettingInt('proxy_type') == 2:
proxy_type = 'socks5'
proxy = {proxy_type : Addon().getSettingString('proxy_url')}
else:
proxy = {}
if '{' in url:
res_raw = json.loads(url)
resolutions = []
for res in res_raw.keys():
resolutions.append(res_raw[res])
#print(type(resolutions[int(order)]))
return resolutions[int(order)]['url']
else:
page = scraper.get(url, params={"box_mac" : get_mac(), "box_hardware" : "Kodi FXML Helper"}, proxies=proxy)
raw_page = page.text
if suborder != False:
return json.loads(raw_page)['channels'][int(suborder)]['submenu'][int(order)]['stream_url']
else:
print("suborder is: "+str(suborder))
if page_type == 'json':
if 'channels' in json.loads(raw_page):
return json.loads(raw_page)['channels'][int(order)]['stream_url']
else:
res_raw = json.loads(raw_page)
resolutions = []
for res in res_raw.keys():
resolutions.append(res_raw[res])
#print(type(resolutions[int(order)]))
return resolutions[int(order)]['url']
elif page_type == 'xml':
return fromstring(raw_page).findall('channel')[int(order)].find('stream_url').text
elif page_type == "m3u":
return url
else:
url = get_page(url)
print(url)
return url[0]
def __init__(self, *args, **kwargs):
self.RestartXBMC_ReloadLanguage = False
self.IsModified = False
self.googleTrans = False
self.listitems = []
self.Addon = Addon(AddonId)
self._get_settings()
def do_search(url, request):
if 'youtube.com' in url or 'youtu.be' in url:
return '{"title" : "youtube not supported"}'
# if 'http://' not in url or 'https://' not in url:
# url = 'http://' + url
if 'https://' in url:
url = url.replace('https://', 'http://')
scraper = cfscrape.create_scraper()
cookie = {"sid" : Addon().getSettingString('fork_cookie')}
if Addon().getSettingBool('enable_proxy') == True:
if Addon().getSettingInt('proxy_type') == 0:
proxy_type = 'http'
elif Addon().getSettingInt('proxy_type') == 1:
proxy_type = 'socks4'
elif Addon().getSettingInt('proxy_type') == 2:
proxy_type = 'socks5'
proxy = {proxy_type : Addon().getSettingString('proxy_url')}
else:
proxy = {}
#print("requesting page: \""+page.url+"\"")
if len(Addon().getSettingString('email')) > 0:
page = scraper.get(url, params={"search" : request, "box_mac" : get_mac(), "box_hardware" : "Kodi FXML Helper", "box_user" : Addon().getSettingString('email')}, cookies=cookie, proxies=proxy)
else:
page = scraper.get(url, params={"search" : request, "box_mac" : get_mac(), "box_hardware" : "Kodi FXML Helper"}, cookies=cookie, proxies=proxy)
raw_page = page.text
return [raw_page, page.url, url]
def __init__(self):
kodi_version = xbmc.getInfoLabel('System.BuildVersion')[:2]
# Kodistubs return an empty string
if kodi_version and kodi_version >= '17':
self._estuary = True
else:
self._estuary = False
self._texture_dir = os.path.join(Addon('script.module.pyxbmct').getAddonInfo('path'),
'lib', 'pyxbmct', 'textures')
def __init__(self):
sdir = xbmc.getSkinDir()
if 'estuary' in sdir:
self._estuary = True
else:
self._estuary = False
self._texture_dir = os.path.join(
Addon('script.stream-cinema-wizard').getAddonInfo('path'),
'resources', 'lib', 'pyxbmct', 'textures')
def __init__(self):
kodi_version = xbmc.getInfoLabel('System.BuildVersion')[:2]
# Kodistubs return an empty string
if kodi_version and int(kodi_version) >= 17:
self._estuary = True
else:
self._estuary = False
self._texture_dir = os.path.join(Addon('plugin.video.OTV_MEDIA').getAddonInfo('path'),
'pyxbmct', 'textures')
def __init__(self, text=''):
self._window = xbmcgui.Window(12005)
self._back = xbmcgui.ControlImage(10, 20, 830, 60,
os.path.join(Addon().getAddonInfo('path'),
'resources', 'icons',
'OverlayDialogBackground.png'))
self._label = xbmcgui.ControlLabel(30, 35, 800, 50, text, textColor='0xFFFFFF00')
self._is_added = False
self._temp = ''
def _subtitle_profiles():
from xbmcaddon import Addon
isa_version = g.remove_ver_suffix(
g.py2_decode(Addon('inputstream.adaptive').getAddonInfo('version')))
subtitle_profile = ['webvtt-lssdh-ios8']
if g.ADDON.getSettingBool('disable_webvtt_subtitle') \
or not common.is_minimum_version(isa_version, '2.3.8'):
subtitle_profile = ['simplesdh']
return subtitle_profile
def auth():
login = Addon().getSettingString('email')
password = Addon().getSettingString('password')
if len(login) == 0 or len(password) == 0:
return Dialog().notification(Addon().getLocalizedString(32075), Addon().getLocalizedString(32076), icon=NOTIFICATION_ERROR)
response = json.loads(get_page(f"http://forkplayer.tv/xml/account.php?act=submit&login={login}&password={password}")[0])
if 'error' in response:
Dialog().notification(Addon().getLocalizedString(32070), response['error'], icon=NOTIFICATION_ERROR)
else:
Addon().setSetting('fork_cookie', response['setcookie']['sid'])
Dialog().notification(Addon().getLocalizedString(32066), Addon().getLocalizedString(32069), icon=NOTIFICATION_INFO)
def _get_logger():
addon_id = Addon().getAddonInfo("id")
if addon_id is str:
addon_id = None
logger = logging.getLogger(addon_id)
logger.setLevel(logging.DEBUG)
handler = XBMCHandler()
handler.setFormatter(logging.Formatter('[%(name)s] %(message)s'))
logger.addHandler(handler)
return logger
def get_setting(key, default=None):
"""Get an add-on setting as string"""
# We use Addon() here to ensure changes in settings are reflected instantly
try:
value = to_unicode(Addon().getSetting(key))
except RuntimeError: # Occurs when the add-on is disabled
return default
if value == '' and default is not None:
return default
return value
def pvrsetup():
IDdoADDON = 'pvr.iptvsimple'
pathTOaddon = os.path.join(translatePath(
'special://home/addons'), IDdoADDON)
pathTOaddon2 = os.path.join(translatePath(
'special://xbmc/addons'), IDdoADDON)
if os.path.exists(pathTOaddon) or os.path.exists(pathTOaddon2):
Addon(IDdoADDON).setSetting(
'm3uPath', os.path.join(translatePath('special://home/addons/plugin.video.jiotv/resources/extra').decode('utf-8'), 'jiotv.m3u'))
Addon(IDdoADDON).setSetting(
'epgUrl', "https://kodi.botallen.com/tv/epg.xml")
Addon(IDdoADDON).setSetting(
'epgPathType', '1')
Addon(IDdoADDON).setSetting(
'm3uPathType', '0')
else:
executebuiltin('InstallAddon(%s)' % (IDdoADDON))
executebuiltin('SendClick(11)'), sleep(2), Dialog().ok(
"Add-on Install", "The addon was not present. Please wait for installation to finish and try again.")
def __init__(self):
kodi_version = xbmc.getInfoLabel('System.BuildVersion')[:2]
# Kodistubs return an empty string
if kodi_version and int(kodi_version) >= 17:
self._estuary = True
else:
self._estuary = False
ares_wizard_dir = os.path.join(
Addon('script.areswizard').getAddonInfo('path'), 'pyxbmct')
self._texture_dir = os.path.join(ares_wizard_dir, 'textures')
def _inputstream_version(self):
"""Return the requested inputstream version"""
from xbmcaddon import Addon
try:
addon = Addon(self.inputstream_addon)
except RuntimeError:
return None
from .unicodehelper import to_unicode
return to_unicode(addon.getAddonInfo('version'))
def getClientID():
# return a Client ID to use for Twitch API
client_id = Addon().getSetting(
'oauth_client_id') # get from settings
if not client_id: # not in settings
try:
client_id = b64decode(Keys.CLIENT_ID) # use Keys.CLIENT_ID
except:
client_id = ''
return client_id
def get_skin_name(skin_list):
list = []
gui_xml=os.path.join(xbmc.translatePath("special://userdata"),"guisettings.xml")
skin_current = read_xml_entry(gui_xml,"lookandfeel","skin")
for ID in skin_list:
skinname = Addon( ID ).getAddonInfo('name')
if ID == skin_current:
skinname = "[COLOR=selected]"+skinname+" [B](SELECTED)[/B][/COLOR]"
list.append(skinname)
return list
def __init__(self):
xbmc.Player.__init__(self)
# Addon object to get addon settings
self.xbmc_addon = Addon()
# initialize class vars
self.chase_play_event = False # flag that a seek occurred past the video's duration
self.orig_file_size = 0 # video file size when playback is started
self.orig_total_time = 0 # video duration when playback is started
self.video_is_file = False # video is a locally-accessible file
self.restart_seek_time = 0 # time to seek
def main_menu():
''' The Regio TV plugin main menu '''
from xbmcaddon import Addon
from xbmcgui import ListItem
import xbmcplugin
xbmcplugin.setContent(plugin.handle, content='files')
xbmcplugin.setPluginCategory(plugin.handle, category='Zenders')
xbmcplugin.setPluginFanart(plugin.handle,
image=Addon().getAddonInfo('fanart'))
xbmcplugin.addSortMethod(plugin.handle,
sortMethod=xbmcplugin.SORT_METHOD_UNSORTED)
xbmcplugin.addSortMethod(plugin.handle,
sortMethod=xbmcplugin.SORT_METHOD_LABEL)
listing = []
for channel in CHANNELS:
is_folder = False
is_playable = True
label = '{name} [COLOR gray]| {label}[/COLOR]'.format(**channel)
plot = '[B]{name}[/B]\nRegio {label}\n\n[I]{description}[/I]\n\n[COLOR yellow]{website}[/COLOR]'.format(
**channel)
list_item = ListItem(label=label,
label2=channel.get('label'),
offscreen=True)
list_item.setProperty(key='IsPlayable',
value='true' if is_playable else 'false')
list_item.setInfo(type='video',
infoLabels=dict(
lastplayed='',
mediatype='video',
playcount=0,
plot=plot,
))
list_item.setArt(
dict(
icon='DefaultAddonPVRClient.png',
thumb=channel.get('logo'),
))
# FIXME: The setIsFolder method is new in Kodi18, so we cannot use it just yet.
# list_item.setIsFolder(is_folder)
url = channel.get('live_stream')
if channel.get('referer'):
url += '|referer=' + channel.get('referer')
listing.append((url, list_item, is_folder))
succeeded = xbmcplugin.addDirectoryItems(plugin.handle, listing,
len(listing))
xbmcplugin.endOfDirectory(plugin.handle,
succeeded,
updateListing=False,
cacheToDisc=True)
def update_service():
# this read the settings
settings = tools.Settings()
# define the browser
browser = tools.Browser()
#Begin Service
if settings.service == 'true':
options = {
'Estrenos': '%s/categoria/1/estrenos/modo:listado/pag:',
'Peliculas': '%s/categoria/2/peliculas/modo:listado/pag:',
'Peliculas HDRip':
'%s/categoria/13/peliculas-hdrip/modo:listado/pag:'
}
ret = int(Addon().getSetting('option'))
if ret < len(options):
url_search = options.values()[ret] % settings.url_address
title = []
magnet = []
if settings.pages == 0:
settings.pages = 1 # manual pages if the parameter is zero
for page in range(1, settings.pages + 1):
if settings.time_noti > 0:
settings.dialog.notification(
settings.name_provider,
'Checking Online page %s...' % page, settings.icon,
settings.time_noti)
settings.log('[%s] %s%d' %
(settings.name_provider_clean, url_search, page))
if browser.open(url_search + str(page)):
data = browser.content
for (torrent, name) in re.findall(r'/torrent/(.*?)/(.*?)"',
data):
info = tools.format_title(name)
title.append(info['title'].replace('-', ' '))
magnet.append(settings.url_address + '/get-torrent/' +
torrent) # create torrent to send P
if int(page) % 10 == 0:
sleep(3000) # to avoid too many connections
else:
settings.log(
'[%s] >>>>>>>%s<<<<<<<' %
(settings.name_provider_clean, browser.status))
settings.dialog.notification(settings.name_provider,
browser.status, settings.icon,
1000)
break
if len(title) > 0:
tools.integration(filename=title,
magnet=magnet,
type_list='MOVIE',
folder=settings.movie_folder,
name_provider=settings.name_provider,
silence=True)
del settings
del browser
