def SaveCookies(session, cookies_name="tmp_cookies"):
try:
path = xbmc.translatePath(os.path.join(TMP_FOLDER, cookies_name))
session.cookies.save(filename=path, ignore_discard=True, ignore_expires=True)
xbmc.log("Cookies saved!",1)
except Exception as e:
pass
def Log(message,log_level=xbmc.LOGDEBUG):
xbmc.log(u"[Kodi4VN] {0}".format(message), log_level)
try:
pass
except Exception as e:
xbmc.log(u"Logging Failed: {0}".format(e))
Noti("Logging Failed!!!", e)
def RetryBlogspot(url):
for i in range(30):
res = Request(url, method="HEAD")
if res.status_code < 300:
xbmc.log("blogspot link retry successfully!", 1)
return res.url
raise Exception('RetryBlogspot Failed!!!')
def Log(msg, level=def_loglevel):
if level == xbmc.LOGDEBUG and s.verbLog:
level = def_loglevel
fi = getframeinfo(currentframe().f_back)
msg = '[{0}]{2} {1}'.format(
g.__plugin__, msg,
'' if not s.verbLog else ' {}:{}'.format(opb(fi.filename), fi.lineno))
xbmc.log(py2_encode(msg), level)
def log(self, txt='', level=xbmc.LOGDEBUG):
''' Log a text into the Kodi-Logfile '''
try:
txt = toUnicode(txt)
xbmc.log("[%s] %s" % (self.pluginName, txt), level)
except:
xbmc.log("[%s] Logging Error" % self.pluginName, xbmc.LOGERROR)
traceback.print_exc()
def delKeyword(keyword):
xbmc.log('keyword: ' + keyword)
conn = sqlite3.connect(favoritesdb)
c = conn.cursor()
c.execute("DELETE FROM keywords WHERE keyword = ?", (keyword,))
conn.commit()
conn.close()
xbmc.executebuiltin('Container.Refresh')
def addKeyword(keyword):
xbmc.log(keyword)
conn = sqlite3.connect(favoritesdb)
conn.text_factory = str
c = conn.cursor()
c.execute("INSERT INTO keywords VALUES (?)", (keyword,))
conn.commit()
conn.close()
def openURL(url):
xbmc.log("Opening %s" % url)
req = urllib_request.Request(url)
req.add_header('Referer', 'https://www.empflix.com/')
response = urllib_request.urlopen(req)
link = response.read().decode('utf-8')
response.close()
return link
def addSupportedLinks(gurl, name, thumbnail):
for each in SUPPORTEDSITES:
if each in thumbnail:
realurl = 'https://fantasti.cc%s' % gurl
mode = 4
addLink(name, realurl, mode, thumbnail)
return
xbmc.log('Unsupported site %s' % thumbnail)
def log(msg, level=xbmc.LOGDEBUG):
try:
msg = str(msg)
except:
pass
if DEBUG == False and level != xbmc.LOGERROR: return
if level == xbmc.LOGERROR: msg += ' ,' + traceback.format_exc()
xbmc.log(ADDON_ID + '-' + ADDON_VERSION + '-' + msg, level)
def regPseudoTV():
while not MONITOR.abortRequested():
if (xbmc.getCondVisibility('System.HasAddon(service.iptv.manager)')
and xbmc.getCondVisibility(
'System.HasAddon(plugin.video.pseudotv.live)')):
if REAL_SETTINGS.getSettingBool('iptv.enabled'):
try:
# Manager Info
IPTV_MANAGER = xbmcaddon.Addon(id='service.iptv.manager')
IPTV_PATH = IPTV_MANAGER.getAddonInfo('profile')
IPTV_M3U = os.path.join(IPTV_PATH, 'playlist.m3u8')
IPTV_XMLTV = os.path.join(IPTV_PATH, 'epg.xml')
except Exception as e:
xbmc.log(
'%s-%s-regPseudoTV failed! %s' %
(ADDON_ID, ADDON_VERSION, e), xbmc.LOGERROR)
break
asset = {
'iptv': {
'type':
'iptv',
'name':
ADDON_NAME,
'icon':
ICON.replace(ADDON_PATH, 'special://home/addons/%s/' %
(ADDON_ID)).replace('\\', '/'),
'm3u': {
'path': IPTV_M3U,
'slug': '@%s' % (slugify(ADDON_NAME))
},
'xmltv': {
'path': IPTV_XMLTV
},
'id':
ADDON_ID
}
}
asset['vod'] = [{
'type':
'vod',
'name':
'HDHomerun %s' % (LANGUAGE(30111)),
'description':
'',
'icon':
LOGO,
'path':
'plugin://%s/recordings/All' % (ADDON_ID),
'id':
ADDON_ID
}]
xbmcgui.Window(10000).setProperty(PROP_KEY, json.dumps(asset))
WAIT_TIME = 900
else:
xbmcgui.Window(10000).clearProperty(PROP_KEY)
WAIT_TIME = 300
if MONITOR.waitForAbort(WAIT_TIME): break
def Request(url,
method="GET",
headers=DEFAULT_HEADERS,
additional_headers=None,
data=None,
session=None,
allow_redirects=True,
timeout=10,
load_cookies=True,
mobile=False):
if additional_headers:
headers.update(additional_headers)
try:
session = CacheControl(session)
except Exception as e:
pass
# Error("Init web cache failed!!!", e)
if mobile:
headers["User-Agents"] = MOBILE_IOS_AGENTS
xbmc.log("Requests headers: {0}".format(json.dumps(headers)), 1)
if session:
session.headers.update(headers)
domain = re.search("https*\://(.+?)($|/)", url).group(1)
if load_cookies:
LoadCookies(session, cookies_name=domain)
if data:
response = session.post(url,
data=data,
allow_redirects=allow_redirects,
timeout=timeout,
verify=False)
else:
if method == "HEAD":
response = session.head(url,
allow_redirects=allow_redirects,
timeout=timeout,
verify=False)
else:
response = session.get(url,
allow_redirects=allow_redirects,
timeout=timeout,
verify=False)
response.encoding = "utf8"
SaveCookies(session, cookies_name=domain)
return response
else:
if method == "HEAD":
return requests.head(url,
headers=headers,
allow_redirects=allow_redirects,
timeout=timeout,
verify=False)
else:
return requests.get(url,
headers=headers,
allow_redirects=allow_redirects,
timeout=timeout,
verify=False)
def logException(self, e, txt=''):
''' Logs an Exception as Error Message '''
try:
if txt:
txt = toUnicode(txt)
xbmc.log("[%s] %s\n%s" % (self.pluginName, txt, str(e)),
level=xbmc.LOGERROR)
except:
pass
def PLog(msg, loglevel=xbmc.LOGDEBUG):
if DEBUG == 'false':
return
#if isinstance(msg, unicode): # entf. mit six
# msg = msg.encode('utf-8')
# loglevel = xbmc.LOGNOTICE # s.o.
# PLog('loglevel: ' + str(LOG_MSG))
xbmc.log("%s --> %s" % (NAME, msg), level=LOG_MSG)
def log_message(msg, level=xbmc.LOGDEBUG):
curr_frame = currentframe()
xbmc.log(
FORMAT.format(id=ADDON_ID,
version=ADDON_VERSION,
filename=os.path.basename(
curr_frame.f_back.f_back.f_code.co_filename),
lineno=curr_frame.f_back.f_back.f_lineno,
message=msg), level)
def i18n(self, string_id):
try:
return addon.getLocalizedString(self.strings[string_id]).encode(
'utf-8', 'ignore')
except Exception as e:
xbmc.log(
'%s: Failed String Lookup: %s (%s)' %
(get_name(), string_id, e), xbmc.LOGWARNING)
return string_id
def SaveCookies(session, cookies_name="tmp_cookies"):
try:
path = xbmc.translatePath(os.path.join(TMP_FOLDER, cookies_name))
session.cookies.save(filename=path,
ignore_discard=True,
ignore_expires=True)
xbmc.log("Cookies saved!", 1)
except Exception as e:
pass
def utc_to_local(utc_dt):
# get integer timestamp to avoid precision lost
timestamp = calendar.timegm(utc_dt.timetuple())
xbmc.log(str(timestamp))
if timestamp < 1:
timestamp = 1
local_dt = datetime.fromtimestamp(timestamp)
assert utc_dt.resolution >= timedelta(microseconds=1)
return local_dt.replace(microsecond=utc_dt.microsecond)
def setLastPlayedPosition(self, recording_id, position):
xbmc.log("setLastPlayedPosition start")
method = 'recording.watched.set'
method += '&recording_id=' + str(recording_id) + '&position=' + str(
position)
ret, result = doRequest5(self, method)
if not ret:
print(result)
def __init__(self):
self.settings = self._get_addon()
self.addon_name = CONFIG['name']
xbmc.log(
self.addon_name + '.settings -> Reading settings configuration',
xbmc.LOGDEBUG)
self.stream = self.settings.getSetting('streaming')
self.picture_mode = False
self._settings = {}
def main():
if xbmc.getInfoLabel('Window(10000).Property(script.plex.service.started)'):
# Prevent add-on updates from starting a new version of the addon
return
xbmcgui.Window(10000).setProperty('script.plex.service.started', '1')
if xbmcaddon.Addon().getSetting('kiosk.mode') == 'true':
xbmc.log('script.plex: Starting from service (Kiosk Mode)', xbmc.LOGINFO)
xbmc.executebuiltin('RunScript(script.plex)')
def log(msg, level=xbmc.LOGDEBUG):
try:
msg = str(msg)
except Exception as e:
'log str failed! %s' % (str(e))
if not DEBUG and level != xbmc.LOGERROR: return
try:
xbmc.log('%s-%s-%s' % (ADDON_ID, ADDON_VERSION, msg), level)
except Exception as e:
'log failed! %s' % (e)
def _write_message(cls, message, level=xbmc.LOGDEBUG):
# type: (Text, int) -> None
curr_frame = inspect.currentframe()
xbmc.log(
cls.FORMAT.format(id=ADDON_ID,
version=ADDON_VERSION,
filename=os.path.basename(
curr_frame.f_back.f_back.f_code.co_filename),
lineno=curr_frame.f_back.f_back.f_lineno,
message=message), level)
def PLog(msg, loglevel=xbmc.LOGDEBUG):
if DEBUG == 'false':
return
#if isinstance(msg, unicode): # entf. mit six
# msg = msg.encode('utf-8')
loglevel = xbmc.LOGNOTICE
# PLog('loglevel: ' + str(loglevel))
if loglevel >= 2:
xbmc.log("%s --> %s" % (NAME, msg), level=loglevel)
def Log(msg, level=xbmc.LOGNOTICE):
from inspect import currentframe, getframeinfo
from os.path import basename as opb
if level == xbmc.LOGDEBUG and var.verbLog:
level = xbmc.LOGNOTICE
fi = getframeinfo(currentframe().f_back)
msg = '[{0}]{2} {1}'.format(
pluginname, msg, '' if not var.verbLog else ' {}:{}'.format(
opb(fi.filename), fi.lineno))
xbmc.log(py2_encode(msg), level)
def GSheet2KSwift(url_path="0", sheet_id="", tq="select *"):
query_url = "https://docs.google.com/spreadsheets/d/{sid}/gviz/tq?gid={gid}&headers=1&tq={tq}"
if "@" in url_path:
xbmc.log("Found gid@sid path", 1)
url_path, sheet_id = url_path.split("@")
url = query_url.format(sid=sheet_id, tq=urllib.quote(tq), gid=url_path)
res = Request(url)
_re = "google.visualization.Query.setResponse\((.+?)\);"
_json = json.loads(re.search(_re, res.encode("utf8")).group(1))
def ERROR(msg=None, hide_tb=False):
if msg:
LOG('ERROR: {0}'.format(msg))
if hide_tb and not DEBUG:
errtext = sys.exc_info()[1]
LOG('%s::%s (%d) - %s' %
(msg or '?', sys.exc_info()[2].tb_frame.f_code.co_name,
sys.exc_info()[2].tb_lineno, errtext))
return
xbmc.log(traceback.format_exc(), xbmc.LOGINFO)
def apply_filter(filters):
API_URL = 'http://www.einthusan.com/webservice/filters.php'
result = HTTPInterface.http_post(API_URL, data=filters)
response_json = {}
try:
response_json = json.loads(result)
except ValueError:
xbmc.log("Value Error: Error when decoding JSON", level=LOGERROR)
xbmc.log(result, level=LOGERROR)
return response_json
def _error(self):
type, value, traceback = sys.exc_info()
filename = traceback.tb_frame.f_code.co_filename
linenumber = traceback.tb_lineno
name = traceback.tb_frame.f_code.co_name
errortype = type.__name__
errormessage = str(errortype) + ' -> ' + str(value.msg)
parameters = [filename, linenumber, name, errormessage]
parameters = ' | '.join([str(parameter) for parameter in parameters])
xbmc.log('control.addonInfo(name) ORION [ERROR]: ' + parameters, xbmc.LOGERROR)
def save_move_details_to_cache(cache_db_file, id, name, picture):
try:
conn = sqlite3.connect(cache_db_file)
cursor = conn.cursor()
cursor.execute('INSERT INTO movie_detail_cache VALUES ("' + str(id) +
'","' + str(name) + '","' + str(picture) + '")')
conn.commit()
except:
xbmc.log("Exception while saving movie detail to cache", xbmc.LOGERROR)
return None
def LogCaller():
frame = currentframe().f_back
fcaller = getframeinfo(frame.f_back)
fcallee = getframeinfo(frame)
msg = '[{}] {}:{} called from: {}:{}'.format(g.__plugin__,
opb(fcallee.filename),
fcallee.lineno,
opb(fcaller.filename),
fcaller.lineno)
xbmc.log(msg, Log.INFO)
def getUrl2(url):
if familyFilter == "1":
ff = "on"
else:
ff = "off"
xbmc.log('DAILYMOTION - The url is {0}'.format(url), xbmc.LOGDEBUG)
headers = {'User-Agent': _UA}
cookie = {'lang': language, 'ff': ff}
r = requests.get(url, headers=headers, cookies=cookie)
return r.text
def SEARCH_RESULTS(url, html=False):
# this function scrapes the search results pages
# accepts page source code (html) for any searches where there is only one
# page of results
if html is False:
xbmc.log(url)
html = get_html(url)
match = re.compile(r'searchVideo">.+?href="([^"]+).+?src="([^"]+).+?n>([^<]+)', re.DOTALL
).findall(html)
for gurl, thumbnail, name in match:
addSupportedLinks(gurl, name, thumbnail)
def log_message(msg, level=xbmc.LOGDEBUG):
curr_frame = currentframe()
xbmc.log(
FORMAT.format(
id=addon_id,
version=addon_version,
filename=os.path.basename(curr_frame.f_back.f_back.f_code.co_filename),
lineno=curr_frame.f_back.f_back.f_lineno,
message=msg
),
level
)
def String(s):
try:
return str(s)
except:
try:
return str(s.encode('utf-8','ignore'))
except:
try:
return str(s.decode('utf-8','ignore').encode('utf-8','ignore'))
except:
xbmc.log("Convert to string failed!!!", 1)
return s
def GSheet2KSwift(url_path="0", sheet_id="", tq="select *"):
query_url = "https://docs.google.com/spreadsheets/d/{sid}/gviz/tq?gid={gid}&headers=1&tq={tq}"
if "@" in url_path:
xbmc.log("Found gid@sid path", 1)
url_path, sheet_id = url_path.split("@")
url = query_url.format(
sid = sheet_id,
tq = urllib.quote(tq),
gid = url_path
)
res = Request(url)
_re = "google.visualization.Query.setResponse\((.+?)\);"
_json = json.loads(re.search(_re, res.encode("utf8")).group(1))
def exitCleanUp(self):
if xbmc.Player().isPlayingVideo():
xbmc.Player().stop()
self.renderstop = False
while self.state == videoState.playing:
xbmc.sleep(100)
import glob
fileNames = glob.glob(xbmc.translatePath('special://temp') + 'knew5/emulate*.png' )
for file in fileNames:
try:
os.remove(file)
except:
xbmc.log('Error deleting ' + file)
self.exit = True
self.close()
def getContext(self):
if self.settings.XNEWA_CONTEXT_POP == False:
self.exitCleanUp()
return
url = None
keyBase = ''
dialog = xbmcgui.Dialog()
value = dialog.select( 'Enter selection', [ 'Remote Keys', 'Recordings', 'TV Guide', 'Main Menu', 'Exit Web Client', '0', '1', '2', '3', '4', '5','6', '7', '8', '9'])
xbmc.log(str(value))
if value == 4:
self.exitCleanUp()
elif value == 2:
url = keyBase + '112'
elif value == 1:
url = keyBase + '119'
elif value == 3:
url = keyBase + '120'
elif value == 0:
value = dialog.select( 'Navigation Selection', [ 'Home', 'Page Up', 'Page Down', 'Fast Forward', 'Rewind', 'Skip Next', 'Skip Previous', 'Red', 'Green', 'Yellow', 'Blue'])
xbmc.log(str(value))
if value == 0:
url = keyBase + '36'
elif value == 1:
url = keyBase + '33'
elif value == 2:
url = keyBase + '34'
elif value == 3:
url = keyBase + str(70|0x20000)
elif value == 4:
url = keyBase + str(82|0x20000)
elif value == 5:
url = keyBase + str(39|0x20000)
elif value == 6:
url = keyBase + str(37|0x20000)
elif value == 7:
url = keyBase + str(82|0x40000)
elif value == 8:
url = keyBase + str(71|0x40000)
elif value == 9:
url = keyBase + str(89|0x40000)
elif value == 10:
url = keyBase + str(66|0x40000)
elif value >=5 and value <= 14:
url = keyBase + str(value + 43)
return url
def Request(
url,
method="GET",
headers=DEFAULT_HEADERS,
additional_headers=None,
data=None,
session=None,
allow_redirects=True,
timeout=10,
load_cookies=True,
mobile=False
):
if additional_headers:
headers.update(additional_headers)
try:
session = CacheControl(session)
except Exception as e:
pass
# Error("Init web cache failed!!!", e)
if mobile:
headers["User-Agents"] = MOBILE_IOS_AGENTS
xbmc.log("Requests headers: {0}".format(json.dumps(headers)), 1)
if session:
session.headers.update(headers)
domain = re.search("https*\://(.+?)($|/)", url).group(1)
if load_cookies:
LoadCookies(session, cookies_name=domain)
if data:
response = session.post(url, data=data, allow_redirects=allow_redirects, timeout=timeout, verify=False)
else:
if method == "HEAD":
response = session.head(url, allow_redirects=allow_redirects, timeout=timeout, verify=False)
else:
response = session.get(url, allow_redirects=allow_redirects, timeout=timeout, verify=False)
response.encoding = "utf8"
SaveCookies(session, cookies_name=domain)
return response
else:
if method == "HEAD":
return requests.head(url, headers=headers, allow_redirects=allow_redirects, timeout=timeout, verify=False)
else:
return requests.get(url, headers=headers, allow_redirects=allow_redirects, timeout=timeout, verify=False)
def render(self):
fullRefresh = 0
while xbmc.abortRequested == False and self.exit == False:
if not xbmc.Player().isPlayingVideo():
if self.state == videoState.started:
if isinstance(self.t1, Thread):
#print self.t1.is_alive(), self.renderstop, self.state, xbmc.Player().isPlayingVideo()
if self.t1.isAlive() == False:
self.state = videoState.error
elif xbmc.Player().isPlayingAudio():
self.state = videoState.inactive
if self.renderstop == False:
fullRefresh += 1
if fullRefresh < 30 and self.state == videoState.inactive:
if self.inControl == False and self.xnewa.sid != None:
self.getActivity(True)
if self.renderstop == True:
self.renderstop = False
self.getScreen()
self.getActivity()
else:
fullRefresh = 0
import glob
fileNames = glob.glob(xbmc.translatePath('special://temp') + 'knew5/emulate*.png' )
for file in fileNames:
try:
os.remove(file)
except:
xbmc.log('Error deleting ' + file)
if self.state == videoState.playing or self.state == videoState.error or self.state == videoState.stopped:
if self.sdlmode != SDL.disabled:
if self.skipStop == False:
try:
url = self.base + '/control?media=stop'
if self.state == videoState.error:
url += '&message=Player%20error'
url += self.xnewa.client
screenFile1 = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
xbmc.log(url)
pngfile = urlopen(url)
pngfile.close()
except Exception as err:
print(err)
else:
self.skipStop = False
self.setOSDMode(True)
self.sidUpdate()
self.state = videoState.inactive
url = self.base + '/control?key=131188' + self.xnewa.client
xbmc.log(url)
try:
jpgfile = urlopen(url)
screenFile = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
output = open(screenFile,'wb')
output.write(jpgfile.read())
output.close()
self.image.setImage(screenFile,False)
self.getActivity()
except err:
print(err)
xbmc.sleep(1000)
else:
self.state = videoState.playing
if self.sdlmode == SDL.full:
if self.wasFullScreen:
if xbmc.getCondVisibility('videoplayer.isfullscreen') == 0:
self.wasFullScreen = False
url = self.base + '/control?move=49x57' + self.xnewa.client
screenFile1 = xbmc.translatePath('special://temp') + 'knew5/emulate-a'+ str(time.time()) + '.png'
xbmc.log(url)
try:
pngfile = urlopen(url)
output = open(screenFile1,'wb')
output.write(pngfile.read())
output.close()
pngfile.close()
self.image.setImage(screenFile1,False)
self.getActivity()
except Exception as err:
print(err)
try:
url = self.base + '/control?media=' + str(xbmc.Player().getTime()) + self.xnewa.client
screenFile1 = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
xbmc.log(url)
request = Request(url)
pngfile = urlopen(request)
if pngfile.code == 200 and xbmc.getCondVisibility('videoplayer.isfullscreen') == 0:
output = open(screenFile1,'wb')
output.write(pngfile.read())
output.close()
self.image.setImage(screenFile1,False)
# needs rendering always true so just
self.getActivity()
elif pngfile.code == 204:
self.setOSDMode(False)
else:
print(pngfile.code)
pngfile.close()
self.skipStop = False
except Exception as err:
print(err)
pass
xbmc.sleep(1000)
return
def log(message, level=xbmc.LOGDEBUG):
xbmc.log('{0}: {1}'.format(ADDON_ID, message), level)
def onAction(self, action):
try:
actionID = action.getId()
buttonID = action.getButtonCode()
except: return
if buttonID & 0x1000000:
#these are long presses
if actionID not in CONTEXT_MENU and buttonID not in CONTEXT_MENU:
return
if actionID == ACTION_MOUSE_MOVE:
return
ignoreKeys = ( 61650, 61651, 127184, 127185, 323749, 323796 )
if buttonID in ignoreKeys:
return
if not self.ready or self.renderstop:
return
dt = datetime.datetime.now()
now = int(time.mktime(dt.timetuple()))
if now == self.recent[0]:
if self.recent[1] == 2:
xbmc.log('too fast')
return
self.recent[1] = self.recent[1] + 1
else:
self.recent[0] = now
self.recent[1] = 0
retval = self.onLiveAction(actionID,buttonID)
xbmc.log(str(retval))
if retval == True:
return
self.renderstop = True
self.inControl = True
screenFile = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
keyBase = self.base + '/control?time=' + str(now) + '&key='
url = None
pauseActivity = True
if actionID == ACTION_PLAYER_PLAY:
url = keyBase + str(80|0x20000)
elif actionID == ACTION_STOP:
url = keyBase + str(83|0x20000)
self.state = videoState.stopped
elif actionID == ACTION_NEXT_ITEM:
if buttonID & 0xf046 == 0xf046 :
# NextPVR Ctrl-F
url = keyBase + str(70|0x20000)
else:
url = keyBase + str(39|0x20000)
elif actionID == ACTION_PREV_ITEM:
if '/live?channel=' not in xbmc.Player().getPlayingFile():
url = keyBase + str(37|0x20000)
else:
# send ctrl-w
url = keyBase + str(87|0x20000)
elif actionID == ACTION_PLAYER_FORWARD:
url = keyBase + str(70|0x20000)
elif actionID == ACTION_PLAYER_REWIND:
url = keyBase + str(82|0x20000)
elif actionID == ACTION_FIRST_PAGE or actionID == ACTION_INFO:
#home
if self.state == videoState.playing:
# send ctrl-b
url = keyBase + str(66|0x20000)
else:
url = keyBase + '36'
pauseActivity = False
elif buttonID >= 0x2f041 and buttonID <= 0x2f05a:
url = keyBase + str(buttonID&0xff)
elif buttonID & 0x10000:
ctrl = buttonID&0xff
if ctrl == 0x50:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x53:
url = keyBase + str(ctrl|0x20000)
self.renderstop = False
xbmc.Player().stop()
elif ctrl == 0x4b:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x52:
url = keyBase + str(ctrl|0x20000)
elif ctrl == 0x82:
url = keyBase + str(37|0x20000)
elif ctrl == 0x83:
url = keyBase + str(39|0x20000)
elif ctrl == 0x42:
url = keyBase + str(80|0x20000)
elif ctrl == 0x46:
url = keyBase + str(70|0x20000)
elif ctrl == 0x57:
url = keyBase + str(87|0x20000)
elif ctrl == 0x47:
url = keyBase + str(112)
elif ctrl == 0x4d and buttonID & 0x30000:
myKey = self.getContext()
if myKey != None:
url = keyBase + myKey
elif ctrl == 0x4f:
url = keyBase + str(119)
elif ctrl == 0x54:
url = keyBase + str(113)
else:
pass
#print actionID, buttonID, hex(ctrl), hex(actionID)
elif actionID == ACTION_RECORD or actionID == ACTION_QUEUE_ITEM:
url = keyBase + str(75|0x20000)
elif actionID == ACTION_PAUSE:
url = keyBase + '32'
elif buttonID == 0xf02e:
url = keyBase + '46'
elif actionID in MOVEMENT_LEFT:
url = keyBase + '37'
elif actionID in MOVEMENT_UP:
url = keyBase + '38'
if xbmc.Player().isPlayingVideo():
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
url = keyBase + str(70|0x20000)
else:
pauseActivity = False
elif actionID in MOVEMENT_RIGHT:
url = keyBase + '39'
elif actionID in MOVEMENT_DOWN or buttonID == 0xf064:
url = keyBase + '40'
if xbmc.Player().isPlayingVideo():
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
url = keyBase + str(82|0x20000)
else:
pauseActivity = False
elif actionID in MOVEMENT_SCROLL_UP:
url = keyBase + '33'
elif actionID in MOVEMENT_SCROLL_DOWN:
url = keyBase + '34'
elif actionID >= 58 and actionID <= 67:
url = keyBase + str(actionID-10)
elif actionID >= 142 and actionID <= 149:
url = keyBase + str(actionID-92)
elif actionID == ACTION_SELECT_ITEM:
url = keyBase + '13'
elif actionID == KEYBOARD_BACK or buttonID == 61575:
url = keyBase + '8'
elif actionID in EXIT_SCRIPT:
url = keyBase + '27'
elif actionID in CONTEXT_MENU or buttonID in CONTEXT_MENU or actionID == ACTION_MOUSE_DOUBLE_CLICK:
myKey = self.getContext()
if myKey != None:
url = keyBase + myKey
elif actionID == ACTION_TELETEXT_RED:
url = keyBase + str(82|0x40000)
elif actionID == ACTION_TELETEXT_GREEN:
url = keyBase + str(71|0x40000)
elif actionID == ACTION_TELETEXT_YELLOW:
url = keyBase + str(89|0x40000)
elif actionID == ACTION_TELETEXT_BLUE:
url = keyBase + str(66|0x40000)
elif buttonID >= 0xf030 and buttonID <= 0xf039:
url = keyBase + str(buttonID-0xf030+48)
elif buttonID >= 0xf041 and buttonID <= 0xf05a:
if self.state == videoState.playing and buttonID == 0xf05a:
buttonID = 118
url = keyBase + str(buttonID&0xff)
elif buttonID >= 0xf090 and buttonID <= 0xf098:
url = keyBase + str((buttonID&0xff)-32)
elif buttonID == 0xf09b:
#F12 exit
self.exitCleanUp()
elif buttonID == 0x4f092:
#alt-f4'
url = keyBase + str(0x40073)
elif buttonID & 0x40000 or buttonID & 0x20000:
buttonID = buttonID | 0x40000
url = keyBase + str(buttonID&0x400ff)
elif actionID == 122 or actionID == 999 :
if buttonID == 50:
#guide
url = keyBase + '112'
elif buttonID == 49 or buttonID == 101:
# recordings
url = keyBase + '119'
elif buttonID == 24:
#live tv
url = keyBase + '113'
elif buttonID == 7:
#my videos
url = keyBase + '114'
elif buttonID == 9:
#my music
url = keyBase + '115'
elif buttonID == 6:
#my pictures
url = keyBase + '116'
elif buttonID == 248:
#my radio
url = keyBase + '117'
elif buttonID == 44:
#subtitle
xbmc.executebuiltin('Action( NextSubtitle )')
elif buttonID == 196:
# power off
self.exitCleanUp()
pass
elif buttonID == 213:
#display
url = keyBase + '119'
else:
xbmc.log('remote action unsupported {0} {1}'.format(actionID, buttonID))
pass
else:
xbmc.log('action unsupported {0} {1}'.format(actionID, buttonID))
pass
if url :
url = url + self.xnewa.client
#while self.rendering:
# time.sleep(0.1)
xbmc.log(url)
try:
jpgfile = urlopen(url)
output = open(screenFile,'wb')
output.write(jpgfile.read())
output.close()
jpgfile.close()
self.setOSDMode(True)
self.image.setImage(screenFile,False)
xbmc.sleep(25)
except HTTPError as err:
xbmc.log(str(err.code))
print(err)
except URLError as err:
print(err)
self.exit = True
self.close()
except Exception as err:
if err.errno != 104 and err.errno != 10054:
print(err)
self.exit = True
self.close()
else:
xbmc.log('ignoring known error')
if pauseActivity:
self.getActivity()
self.renderstop = False
self.inControl = False
self.ready = True
def onLiveAction(self,actionID,buttonID):
retval = False
if xbmc.Player().isPlayingVideo():
if self.sdlmode != SDL.disabled:
#xbmc.log('video {0} {1}'.format(actionID, buttonID))
if buttonID == 0xf049 or buttonID == 0x1f042 or buttonID == 0x4f042:
# toggle OSD
if self.win.getProperty('showosd') == 'true':
self.setOSDMode(False)
else:
self.setOSDMode(True)
elif (actionID == 26 and buttonID != 0) or buttonID == 0xf023 or buttonID == 0xf054:
#subtitle from remote or #
xbmc.executebuiltin('Action( NextSubtitle )')
retval = True
elif actionID == REMOTE_BACK or actionID == ACTION_BACK or actionID == ACTION_SHOW_GUI:
if self.osdMode == False:
xbmc.executebuiltin('ActivateWindow(fullscreenvideo)')
self.wasFullScreen = True
self.setOSDMode(True)
retval = True
elif actionID == ACTION_PLAYER_FORWARD:
xbmc.executebuiltin('PlayerControl(tempoup)')
retval = True
elif actionID == ACTION_SHOW_OSD or actionID == ACTION_SELECT_ITEM:
if '/live?channel=' not in xbmc.Player().getPlayingFile() and self.osdMode == False:
xbmc.executebuiltin('Action(OSD,fullscreenvideo)')
retval = True
elif actionID == ACTION_PLAYER_REWIND:
xbmc.executebuiltin('PlayerControl(tempodown)')
retval = True
elif actionID == ACTION_BUILT_IN_FUNCTION:
if buttonID == 0xf04d:
#xbmc.executebuiltin('Action(OSD,fullscreenvideo)')
pass
retval = True
elif buttonID == 0xf027 or actionID == ACTION_SMALL_STEP_BACK:
# 'small step'
xbmc.executebuiltin('Seek(-7))')
retval = True
elif buttonID == 0x4f059:
#alt y
xbmc.executebuiltin('ActivateWindow(osdvideosettings)')
retval = True
elif buttonID == 0x4f047 or actionID == 25:
#alt g
xbmc.executebuiltin('ActivateWindow(osdaudiosettings)')
retval = True
elif buttonID == 0xf04f:
xbmc.executebuiltin('ActivateWindow(PlayerProcessInfo)')
retval = True
elif buttonID == 0xf05a or buttonID == 0xf096 or actionID == ACTION_ASPECT_RATIO:
xbmc.executebuiltin('Action(AspectRatio,fullscreenvideo)')
retval = True
elif actionID == ACTION_CONTEXT_MENU and self.settings.XNEWA_CONTEXT_STOP == True:
xbmc.Player().stop()
retval = True
#print 'video pass', actionID, buttonID, retval
else:
xbmc.log('video {0} {1}'.format(actionID, buttonID))
if self.settings.XNEWA_LIVE_SKIN:
self.debug.setLabel('actionID: ' + str(actionID) + ' buttonID: ' + str(hex(buttonID)))
if actionID == REMOTE_BACK:
xbmc.executebuiltin('ActivateWindow(fullscreenvideo)')
self.wasFullScreen = True
self.setOSDMode(True)
retval = True
return retval
def getScreen(self, force=False):
self.rendering = True
self.errors = 0
retval = True
try:
if force:
if self.xnewa.AreYouThere(self.settings.usewol(), self.settings.NextPVR_MAC, self.settings.NextPVR_BROADCAST):
url = self.base + '/control?size=' + self.settings.XNEWA_CLIENT_SIZE
if self.settings.XNEWA_CLIENT_QUALITY == True:
url += '&quality=high'
url += self.xnewa.client
xbmc.log(url)
try:
jpgfile = urlopen(url)
jpgfile.close
if self.sdlmode != SDL.disabled:
try:
url = self.base + '/control?media=stop' + self.xnewa.client
xbmc.log(url)
pngfile = urlopen(url)
pngfile.close()
except Exception as err:
print(err)
except HTTPError as e:
print(e.code)
if e.code == 404:
xbmc.sleep(500)
url = self.base + '/control?media=stop' + self.xnewa.client
xbmc.log(url)
pngfile = urlopen(url)
pngfile.close()
self.errors = self.errors + 1
elif e.code == 403:
self.sidUpdate()
self.getSid()
self.errors = self.errors + 1
else:
print(e)
self.exit = True
self.close()
return False
if self.errors < 3:
self.getScreen(force)
return False
except URLError as err:
print(err)
self.exit = True
self.close()
else:
self.exit = True
self.close()
return False
screenFile = xbmc.translatePath('special://temp') + 'knew5/emulate-'+ str(time.time()) + '.png'
url = self.base + '/control?format=json' + self.xnewa.client
#xbmc.log(url)
try:
self.setOSDMode(True)
jpgfile = urlopen(url)
output = open(screenFile,'wb')
output.write(jpgfile.read())
output.close()
self.image.setImage(screenFile,False)
except HTTPError as e:
xbmc.log(url)
xbmc.log(str(e.code))
retval = False
except URLError as err:
xbmc.log(url)
print(err)
xbmc.log('Abort emulation')
self.exit = True
self.close()
retval = False
except Exception as err:
print(err)
retval = False
self.rendering = False
return retval
def getActivity(self, update=False):
if update:
url = self.base + '/activity?format=json&updates=1' + self.xnewa.client
else:
url = self.base + '/activity?format=json' + self.xnewa.client
import json
print (url)
try:
json_file = urlopen(url)
jsonActivity = json.load(json_file)
json_file.close()
print(jsonActivity)
#xbmc.log(jsonActivity)
if 'url' in jsonActivity:
import re
if jsonActivity['url'] != '':
self.nextUrl = re.sub('[^?&]*client[^&]+&*','',jsonActivity['url'],re.UNICODE)
m = re.search('seek=(\d+)&', self.nextUrl)
if m:
seek = int(m.group(1))
self.nextUrl = re.sub('seek=(\d+)&','',self.nextUrl)
if 'recording_resume' not in jsonActivity:
if self.state == videoState.playing:
xbmc.Player().seekTime(seek)
return
else:
jsonActivity['recording_resume'] = seek
self.nextUrl = unquote(self.nextUrl)
if self.state == videoState.playing:
self.skipStop = True
self.quickPlayer(jsonActivity)
elif 'playlist' in jsonActivity:
self.quickPlayer(jsonActivity)
elif 'action' in jsonActivity:
if jsonActivity['action'] == 'exit':
self.exit = True
xbmc.sleep(250)
import glob
fileNames = glob.glob(xbmc.translatePath('special://temp') + 'knew5/emulate*.png' )
for file in fileNames:
try:
os.remove(file)
except:
xbmc.log('Leaving ' + file)
self.close()
return
elif 'needsRendering' in jsonActivity:
if jsonActivity['needsRendering'] == True:
if isinstance(self.t1, Thread):
if self.t1.is_alive() and self.state == videoState.playing:
xbmc.log('player no render')
self.renderstop = False
else:
self.renderstop = True
else:
self.renderstop = True
self.InControl = False
except URLError as err:
print(err)
self.exit = True
self.close()
except Exception as err:
print(err)
def quickPlayer (self,activity):
from . import details
#print self.nextUrl
Audio = False
self.wasFullScreen = True
windowed = self.settings.XNEWA_LIVE_SKIN
if 'playlist' in activity:
import os
import re
dd = {}
xbmc.PlayList(0).clear()
for playlist in activity['playlist']:
nextUrl = re.sub('[^?&]*client[^&]+&*','',playlist['url'].encode('utf-8'))
xbmc.log(nextUrl)
url = nextUrl.split('=',1)[1]
if url[0:2]=='\\\\':
url = 'smb:'+ url.replace('\\','/')
if xbmcvfs.exists(url) == False:
s = self.base + playlist['url'].replace(' ','+').replace('&f=','&mode=http&f=')
xbmc.log(s)
xbmc.PlayList(0).add(s)
else:
xbmc.PlayList(0).add(url)
dd['movie'] = False
dd['playlist'] = xbmc.PlayList(0)
windowed = False
elif self.nextUrl.startswith('/live?channel'):
try:
#v5
if self.settings.XNEWA_INTERFACE == 'XML' or self.settings.XNEWA_INTERFACE == 'Version5':
url = self.base + '/services?method=channel.listings.current' + self.xnewa.client + '&channel_id=' + str (activity['channel_id'])
xbmc.log(url)
dd1 = self.xnewa._progs2array_xml(url)
else:
url = self.base + '/public/GuideService/Listing' + self.xnewa.jsid + '&channelId=' + str (activity['channel_id'])
xbmc.log(url)
dd1 = self.xnewa._progs2array_json(url)
dd = dd1[0]['progs'][0]
dd['program_oid'] = dd['oid']
#dd['season'] = 0
except Exception as err:
print(err)
dd = {}
dd['program_oid'] = 12346
dd['title'] = activity['channel_name']
dd['subtitle'] = str(activity['channel_number'])
dd['end'] = ''
dd['season'] = 0
dd['desc'] = ''
dd['channel_oid'] = activity['channel_id']
channel = {}
channel[0] = activity['channel_name']
channel[1] = activity['channel_number']
channel[2] = '0'
self.prev_channel = self.channel_number
self.channel_number = activity['channel_number']
dd['channel'] = channel
dd['bookmarkSecs'] = 0
dd['movie'] = False
elif self.nextUrl.startswith('/stream?'):
dd = {}
dd['title'] = 'title'
dd['movie'] = False
dd['filename'] = py2_decode(self.nextUrl.split('=',1)[1]).replace('http://plugin','plugin')
dd['season'] = 0
if 'duration' in activity:
dd['library_duration'] = activity['duration']
else:
import re
m = re.search('.*_(\d{2})(\d{2})(\d{2})(\d{2})(-\d)\.ts', dd['filename'])
if m:
start = int(m.group(1)) * 60 + int(m.group(2))
end = int(m.group(3)) * 60 + int(m.group(4))
#print start
#print end
if start > end:
dd['library_duration'] = (start + end - 1440) * 60
else:
dd['library_duration'] = (end - start) * 60
dd['filename'] = dd['filename'].replace('127.0.0.1',self.xnewa.ip)
#self.getPlaybackPosition(dd['filename'])
dd['nextUrl'] = self.nextUrl
if 'recording_description' in activity:
dd['desc'] = activity['recording_description']
elif 'description' in activity:
dd['desc'] = activity['description']
else:
dd['desc'] = ''
if 'recording_title' in activity:
dd['title'] = activity['recording_title']
elif dd['filename'].startswith('http:'):
if '.m3u8' not in dd['filename']:
Audio = True
elif 'title' in activity:
dd['title'] = activity['title']
if 'recording_subtitle' in activity:
dd['subtitle'] = activity['recording_subtitle']
elif 'subtitle' in activity:
dd['subtitle'] = activity['subtitle']
else:
dd['subtitle'] = None
if 'recording_resume' in activity:
dd['bookmarkSecs'] = activity['recording_resume']
dd['resume'] = activity['recording_resume']
else:
dd['bookmarkSecs'] = 0
if 'album' in activity:
Audio = True
if 'recording_id' in activity:
dd['recording_oid'] = activity['recording_id']
dd['nextUrl'] = '/live?recording=' + dd['recording_oid']
if self.settings.NextPVR_ICON_DL == 'Yes' and self.xnewa.getShowIcon(dd['title']) is None:
self.xnewa.getDetails(self.settings.NextPVR_USER,self.settings.NextPVR_PW,dd['recording_oid'],'R','Yes')
else:
dd['recording_oid'] = 0
if 'Genres' in activity:
dd['genres'] = activity['Genres']
for genre in dd['Genres']:
if genre == "Movie" or genre == "Movies" or genre == "Film":
dd['movie'] = True
break
detailDialog = details.DetailDialog("nextpvr_recording_details.xml", WHERE_AM_I,self.settings.XNEWA_SKIN, xnewa=self.xnewa, settings=self.settings, oid=123, epg=True, type="R")
xbmc.log(str(windowed))
if self.sdlmode == SDL.disabled:
self.setOSDMode(False)
windowed = False
if isinstance(self.t1, Thread):
xbmc.Player().stop()
while self.t1.is_alive():
xbmc.sleep(100)
self.renderstop = False
self.t1 = Thread(target=detailDialog._myPlayer, args=(dd,None,windowed,Audio,False))
self.t1.start()
self.state = videoState.started
#xbmc.executebuiltin('XBMC.ActivateWindow(25)')
#self.player = detailDialog.getPlayer()
#self.player.overlay = self
#xbmc.executebuiltin('ActivateWindow(visualisation)')
#xbmc.executebuiltin('ActivateWindow(musicosd)')
return
def handle(self, record):
if record.levelname == 'WARNING':
xbmc.log(self.fmt.format(record), xbmc.LOGWARNING)
if record.levelname == 'DEBUG':
xbmc.log(self.fmt.format(record), xbmc.LOGDEBUG)
if record.levelname == 'INFO':
xbmc.log(self.fmt.format(record), xbmc.LOGNOTICE)
elif record.levelname == 'ERROR':
xbmc.log(self.fmt.format(record), xbmc.LOGERROR)
elif record.levelname == 'CRITICAL':
xbmc.log(self.fmt.format(record), xbmc.LOGSEVERE)
else:
xbmc.log(self.fmt.format(record), xbmc.LOGNOTICE)
