X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FPlugins%2FExtensions%2FHbbTV%2Fplugin.py;h=2184af26155beda657207eb87f1afa219f2fad79;hp=13d686bf65f9865f5d8f27922e10fb26b4c887c0;hb=2272e55fb58950bd964f6c467faf97f81eecaf57;hpb=d7c3b52708ed64d27664b5d4f2b223a61fbad041 diff --git a/lib/python/Plugins/Extensions/HbbTV/plugin.py b/lib/python/Plugins/Extensions/HbbTV/plugin.py index 13d686b..2184af2 100644 --- a/lib/python/Plugins/Extensions/HbbTV/plugin.py +++ b/lib/python/Plugins/Extensions/HbbTV/plugin.py @@ -20,7 +20,7 @@ from Components.Label import Label, MultiColorLabel from Components.ConfigList import ConfigListScreen from Components.VolumeControl import VolumeControl from Components.Pixmap import Pixmap -from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue +from Components.config import config, ConfigYesNo, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile from enigma import eTimer, eConsoleAppContainer, getDesktop, eServiceReference, iPlayableService, iServiceInformation, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, getPrevAsciiCode, eRCInput, fbClass, eServiceCenter @@ -57,8 +57,43 @@ class GlobalValues: need_restart = False plugin_browser = None + + resX = 0 + resY = 0 + def UpdateInfoBar(self): + if self.resX == 1024 and self.resY == 720: + return + try: + infobar = InfoBar.instance + if infobar._InfoBarShowHide__state != 3: + return + infobar.doTimerHide() + infobar.serviceStarted() + except: pass + __gval__ = GlobalValues() +def setDefaultResolution(x, y): + global __gval__ + __gval__.resX = x + __gval__.resY = y + +def setResolution(xres, yres): + global __gval__ + if __gval__.resX == 1280 and __gval__.resY == 720: + return + from enigma import gMainDC + gMainDC.getInstance().setResolution(xres, yres) + +def restoreResolution(): + global __gval__ + setResolution(1280, 720) + setResolution(__gval__.resX, __gval__.resY) + + if __gval__.resX == 1280 and __gval__.resY == 720: + return + __gval__.UpdateInfoBar() + def setPluginBrowser(browser=None): global __gval__ __gval__.plugin_browser = browser @@ -71,11 +106,11 @@ def getPacketHeaders(): return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl) def setChannelInfo(sid, onid, tsid, name, orgid): - if sid is None: sid = 0; - if onid is None: onid = 0; - if tsid is None: tsid = 0; - if name is None: name = ""; - if orgid is None: orgid = 0; + if sid is None: sid = 0 + if onid is None: onid = 0 + if tsid is None: tsid = 0 + if name is None: name = "" + if orgid is None: orgid = 0 global __gval__ __gval__.channel_info_sid = sid __gval__.channel_info_onid = onid @@ -85,12 +120,12 @@ def setChannelInfo(sid, onid, tsid, name, orgid): print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid) def getChannelInfos(): global __gval__ - print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid, + print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid, __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid) - return (__gval__.channel_info_sid, - __gval__.channel_info_onid, - __gval__.channel_info_tsid, - __gval__.channel_info_name, + return (__gval__.channel_info_sid, + __gval__.channel_info_onid, + __gval__.channel_info_tsid, + __gval__.channel_info_name, __gval__.channel_info_orgid) def isNeedRestart(): @@ -136,91 +171,48 @@ def _pack(opcode, params=None, reserved=0): packed_data = struct.pack(h, m, opcode, len(params), reserved) return packed_data + params -class MMSStreamURL: - headers = [ - 'GET %s HTTP/1.0' - ,'Accept: */* ' - ,'User-Agent: NSPlayer/7.10.0.3059 ' - ,'Host: %s ' - ,'Connection: Close ' - ] - - def __init__(self): - self.sendmsg = '' - for m in self.headers: - self.sendmsg += m + '\n' - self.sendmsg += '\n\n' - - def request(self, host, port=80, location='/'): - sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) - sock.connect((host, port)) - sock.send(self.sendmsg%(location, host)) - print "Request." - print self.sendmsg%(location, host) - fullydata = '' - while 1: - res = sock.recv(1024) - if res == '': break - fullydata += res - sock.close() - return fullydata - - def parse(self, data): - for d in data.splitlines(): - if d.startswith('Location: '): - return d[9:] - return None - - def getLocationData(self, url): - url_list,host,location = None,None,None - try: - url = url[url.find(':')+3:] - url_list = url.split('/') - host = url_list[0] - location = url[len(url_list[0]):] - except Exception, err_msg: - print err_msg - return None - html = self.request(host=host, location=location) - return self.parse(html) - class OpCodeSet: def __init__(self): self._opcode_ = { - "OP_UNKNOWN" : 0x0000 - ,"OP_HBBTV_EXIT" : 0x0001 - ,"OP_HBBTV_OPEN_URL" : 0x0002 - ,"OP_HBBTV_LOAD_AIT" : 0x0003 - ,"OP_HBBTV_UNLOAD_AIT" : 0x0004 - ,"OP_HBBTV_FULLSCREEN" : 0x0005 - ,"OP_HBBTV_TITLE" : 0x0006 - ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009 - ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A - ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101 - ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102 - ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103 - ,"OP_VOD_URI" : 0x0201 - ,"OP_VOD_PLAY" : 0x0202 - ,"OP_VOD_STOP" : 0x0203 - ,"OP_VOD_PAUSE" : 0x0204 - ,"OP_VOD_STATUS" : 0x0205 - ,"OP_VOD_FORBIDDEN" : 0x0206 - ,"OP_VOD_STOPED" : 0x0207 - ,"OP_VOD_SPEED_CTRL" : 0x0208 - ,"OP_VOD_SEEK_CTRL" : 0x0209 - ,"OP_BROWSER_OPEN_URL" : 0x0301 - ,"OP_BROWSER_VKBD_REQ" : 0x0309 - ,"OP_BROWSER_VKBD_RES" : 0x030A - ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B - ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C - ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D - ,"OP_BROWSER_MENU_REQ" : 0x030E - ,"OP_BROWSER_MENU_RES" : 0x030F - ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313 - ,"OP_DVBAPP_VOL_UP" : 0x0401 - ,"OP_DVBAPP_VOL_DOWN" : 0x0402 - ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501 - ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502 + "OP_UNKNOWN" : 0x0000 + ,"OP_HBBTV_EXIT" : 0x0001 + ,"OP_HBBTV_OPEN_URL" : 0x0002 + ,"OP_HBBTV_LOAD_AIT" : 0x0003 + ,"OP_HBBTV_UNLOAD_AIT" : 0x0004 + ,"OP_HBBTV_FULLSCREEN" : 0x0005 + ,"OP_HBBTV_TITLE" : 0x0006 + ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009 + ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A + ,"OP_HBBTV_ABORT_SIG" : 0x000B + ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101 + ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102 + ,"OP_OIPF_GET_CHANNEL_INFO_LIST" : 0x0103 + ,"OP_VOD_URI" : 0x0201 + ,"OP_VOD_PLAY" : 0x0202 + ,"OP_VOD_STOP" : 0x0203 + ,"OP_VOD_PAUSE" : 0x0204 + ,"OP_VOD_STATUS" : 0x0205 + ,"OP_VOD_FORBIDDEN" : 0x0206 + ,"OP_VOD_STOPED" : 0x0207 + ,"OP_VOD_SPEED_CTRL" : 0x0208 + ,"OP_VOD_SEEK_CTRL" : 0x0209 + ,"OP_BROWSER_OPEN_URL" : 0x0301 + ,"OP_BROWSER_VKBD_REQ" : 0x0309 + ,"OP_BROWSER_VKBD_RES" : 0x030A + ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B + ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C + ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D + ,"OP_BROWSER_MENU_REQ" : 0x030E + ,"OP_BROWSER_MENU_RES" : 0x030F + ,"OP_BROWSER_NEED_RELOAD_KEYMAP" : 0x0313 + ,"OP_DVBAPP_VOL_UP" : 0x0401 + ,"OP_DVBAPP_VOL_DOWN" : 0x0402 + ,"OP_DVBAPP_SET_VOL" : 0x0403 + ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501 + ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502 + ,"OP_VIDEOBACKEND_ENABLE" : 0x0601 + ,"OP_VIDEOBACKEND_DISABLE" : 0x0602 + ,"OP_BROWSER_OPEN_YOUTUBETV" : 0x0603 } self._opstr_ = { 0x0000 : "OP_UNKNOWN" @@ -232,6 +224,7 @@ class OpCodeSet: ,0x0006 : "OP_HBBTV_TITLE" ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL" ,0x000A : "OP_HBBTV_CHANGE_CHANNEL" + ,0x000B : "OP_HBBTV_ABORT_SIG" ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL" ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT" ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST" @@ -242,10 +235,10 @@ class OpCodeSet: ,0x0205 : "OP_VOD_STATUS" ,0x0206 : "OP_VOD_FORBIDDEN" ,0x0207 : "OP_VOD_STOPED" - ,0x0208 : "OP_VOD_SPEED_CTRL" - ,0x0209 : "OP_VOD_SEEK_CTRL" + ,0x0208 : "OP_VOD_SPEED_CTRL" + ,0x0209 : "OP_VOD_SEEK_CTRL" ,0x0301 : "OP_BROWSER_OPEN_URL" - ,0x0309 : "OP_BROWSER_VKBD_REQ" + ,0x0309 : "OP_BROWSER_VKBD_REQ" ,0x030A : "OP_BROWSER_VKBD_RES" ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ" ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY" @@ -255,8 +248,12 @@ class OpCodeSet: ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP" ,0x0401 : "OP_DVBAPP_VOL_UP" ,0x0402 : "OP_DVBAPP_VOL_DOWN" - ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY" + ,0x0403 : "OP_DVBAPP_SET_VOL" + ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY" ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID" + ,0x0601 : "OP_VIDEOBACKEND_ENABLE" + ,0x0602 : "OP_VIDEOBACKEND_DISABLE" + ,0x0603 : "OP_BROWSER_OPEN_YOUTUBETV" } def get(self, opstr): @@ -274,22 +271,22 @@ class OpCodeSet: class SocketParams: def __init__(self): self.protocol = None - self.type = None - self.addr = None + self.type = None + self.addr = None self.buf_size = 4096 - self.handler = None - self.timeout = 5 - self.destroy = None + self.handler = None + self.timeout = 5 + self.destroy = None class StreamServer: def __init__(self, params): self._protocol = params.protocol - self._type = params.type - self._addr = params.addr + self._type = params.type + self._addr = params.addr self._buf_size = params.buf_size - self._handler = params.handler - self._timeout = params.timeout - self._destroy = params.destroy + self._handler = params.handler + self._timeout = params.timeout + self._destroy = params.destroy self._terminated = False self._server_thread = None @@ -335,12 +332,12 @@ class StreamServer: def _client(self, conn, addr): try: - send_data = '' + send_data = '' received_data = conn.recv(self._buf_size) if self._handler is not None and not strIsEmpty(received_data): send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB) self._send(conn, send_data) - except Exception, ErrMsg: + except Exception, ErrMsg: try: conn.close() except:pass if self._handler is not None: @@ -352,7 +349,6 @@ class StreamServer: class ServerFactory: def doListenUnixTCP(self, name, handler): def destroy(name): - import os try: if os.path.exists(name): os.unlink(name) @@ -362,10 +358,10 @@ class ServerFactory: params = SocketParams() params.protocol = socket.AF_UNIX - params.type = socket.SOCK_STREAM - params.addr = name - params.handler = handler - params.destroy = destroy + params.type = socket.SOCK_STREAM + params.addr = name + params.handler = handler + params.destroy = destroy streamServer = StreamServer(params) streamServer.start() @@ -434,7 +430,7 @@ class BrowserCommandUtil(OpCodeSet): return False os.write(self._fd, data) print "Send OK!! :", command - except: return False + except: return False return True def sendCommand(self, command, params=None, reserved=0): @@ -455,6 +451,7 @@ class HandlerHbbTV(Handler): ,0x0006 : self._cb_handleSetPageTitle ,0x0009 : self._cb_handleHbbTVRetryOpen ,0x000A : self._cb_handleHbbTVChangeChannel + ,0x000B : self._cb_handleHbbTVAbortSig ,0x0101 : self._cb_handleGetChannelInfoForUrl ,0x0102 : self._cb_handleGetChannelInfoForAIT ,0x0103 : self._cb_handleGetChannelInfoList @@ -464,6 +461,7 @@ class HandlerHbbTV(Handler): ,0x0204 : self._cb_handleVODPlayerPlayPause ,0x0401 : self._cb_handleDVBAppVolUp ,0x0402 : self._cb_handleDVBAppVolDown + ,0x0403 : self._cb_handleDVBAppSetVol ,0x0208 : self._cb_handleVODSpeedCtrl ,0x0209 : self._cb_handleVODSeekCtrl ,0x0501 : self._cb_handleSystemOutOfMemory @@ -471,6 +469,8 @@ class HandlerHbbTV(Handler): ,0x0309 : self._cb_handleShowVirtualKeyboard ,0x030B : self._cb_handlePasteVirtualKeyboard ,0x030E : self._cb_handleBrowserMenuReq + ,0x0601 : self._cb_handleVideobackendEnable + ,0x0602 : self._cb_handleVideobackendDisable } self._on_close_cb = None self._on_set_title_cb = None @@ -481,6 +481,8 @@ class HandlerHbbTV(Handler): self._timer_retry_open = eTimer() self._timer_paste_vkbd = eTimer() self._curren_title = None + self._max_volume = -1 + self._soft_volume = -1 def _handle_dump(self, handle, opcode, data=None): if True: return @@ -518,13 +520,27 @@ class HandlerHbbTV(Handler): self._on_set_title_cb = None return self.doPack(opcode, params, reserved) + def _cb_handleVideobackendEnable(self, opcode, data): + self._handle_dump(self._cb_handleVideobackendEnable, opcode, data) + service = self._session.nav.getCurrentlyPlayingServiceReference() + setBeforeService(service) + self._session.nav.stopService() + return (0, "OK") + + def _cb_handleVideobackendDisable(self, opcode, data): + self._handle_dump(self._cb_handleVideobackendDisable, opcode, data) + before_service = getBeforeService() + if before_service is not None: + self._session.nav.playService(before_service) + return (0, "OK") + def _cb_handleHbbTVChangeChannel(self, opcode, data): self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data) global _g_helper - if _g_helper is None: + if _g_helper is None: return (0, "NOK") dataItems = data.split(":") - sid = dataItems[0] + sid = dataItems[0] tsid = dataItems[1] if not _g_helper.doChangeChannel(sid, tsid): return (0, "NOK") @@ -532,6 +548,7 @@ class HandlerHbbTV(Handler): def _cb_handleBrowserMenuReq(self, opcode, data): self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data) + #restoreResolution() fbClass.getInstance().unlock() eRCInput.getInstance().unlock() browser = getPluginBrowser() @@ -575,10 +592,13 @@ class HandlerHbbTV(Handler): def _cb_virtualKeyboardClosed(self, data=None): fbClass.getInstance().lock() eRCInput.getInstance().lock() + #setResolution(1280, 720) command_util = getCommandUtil() command_util.sendCommand('OP_BROWSER_VKBD_RES', data) + def _cb_handleShowVirtualKeyboard(self, opcode, data): self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data) + #restoreResolution() fbClass.getInstance().unlock() eRCInput.getInstance().unlock() if data == 0 or strIsEmpty(data): @@ -643,16 +663,41 @@ class HandlerHbbTV(Handler): raise Exception("This stream is not support trick play.") return (0, "OK") + def SetVolume(self, volume): + if self._max_volume < 0: + self._max_volume = VolumeControl.instance.volctrl.getVolume() + + self._max_volume += volume + if self._max_volume > 100: + self._max_volume = 100 + elif self._max_volume < 0: + self._max_volume = 0 + + if self._soft_volume > 0: + v = int((self._max_volume * self._soft_volume) / 100) + VolumeControl.instance.volctrl.setVolume(v, v) + else: VolumeControl.instance.volctrl.setVolume(self._max_volume, self._max_volume) + def _cb_handleDVBAppVolUp(self, opcode, data): self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data) - vcm = VolumeControl.instance - vcm.volUp() + self.SetVolume(5) return (0, "OK") def _cb_handleDVBAppVolDown(self, opcode, data): self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data) - vcm = VolumeControl.instance - vcm.volDown() + self.SetVolume(-5) + return (0, "OK") + + def _cb_handleDVBAppSetVol(self, opcode, data): + self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data) + if self._max_volume < 0: + self._max_volume = VolumeControl.instance.volctrl.getVolume() + self._soft_volume = int(data) + + v = 0 + if self._soft_volume > 0 and self._max_volume > 0: + v = int((self._max_volume * self._soft_volume) / 100) + VolumeControl.instance.volctrl.setVolume(v, v) return (0, "OK") def _cb_handleGetChannelInfoForUrl(self, opcode, data): @@ -675,7 +720,7 @@ class HandlerHbbTV(Handler): return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name) def _cb_handleSetPageTitle(self, opcode, data): - self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data) + self._handle_dump(self._cb_handleSetPageTitle, opcode, data) if data.startswith('file://') or data.startswith('http://'): return "OK" if self._on_set_title_cb is not None: @@ -688,6 +733,11 @@ class HandlerHbbTV(Handler): self._on_set_title_cb.remove(x) return (0, "OK") + def _cb_handleHbbTVAbortSig(self, opcode, data): + self._cb_handleCloseHbbTVBrowser(opcode, data) + global __gval__ + return (0, struct.pack('!II', __gval__.resX, __gval__.resY)); + def _cb_handleCloseHbbTVBrowser(self, opcode, data): self._timer_retry_open.stop() try: @@ -705,11 +755,12 @@ class HandlerHbbTV(Handler): command_util = getCommandUtil() command_util.sendCommand('OP_HBBTV_FULLSCREEN', None) - before_service = getBeforeService() if before_service is not None: self._session.nav.playService(before_service) self._vod_uri = None + + #restoreResolution() return (0, "OK") def _cb_handleVODPlayerURI(self, opcode, data): @@ -740,12 +791,13 @@ class HandlerHbbTV(Handler): for ii in range(5): self._vod_service = None try: - print "Try to open vod [%d] : %s" % (ii, url) + #print "Try to open vod [%d] : %s" % (ii, url) + print "Try to open vod" self._vod_service = eServiceReference(4097, 0, url) self._session.nav.playService(self._vod_service) if self._vod_service is not None: return True - except Exception, ErrMsg: + except Exception, ErrMsg: print "OpenVOD ERR :", ErrMsg time.sleep(1) return False @@ -759,7 +811,7 @@ class HandlerHbbTV(Handler): def _cb_handleVODPlayerStop(self, opcode, data): self._handle_dump(self._cb_handleVODPlayerStop, opcode, data) - self.doStop() + self.doStop() return (0, "OK") def _cb_handleVODPlayerPlayPause(self, opcode, data): @@ -779,19 +831,19 @@ class HandlerHbbTV(Handler): from libshm import SimpleSharedMemory _g_ssm_ = None class HbbTVWindow(Screen, InfoBarNotifications): - skin = """ + skin = """ """ def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0): self._session = session + setResolution(1280, 720) fbClass.getInstance().lock() eRCInput.getInstance().lock() Screen.__init__(self, session) InfoBarNotifications.__init__(self) self.__event_tracker = ServiceEventTracker(screen = self, eventmap = { - iPlayableService.evUser+20: self._serviceForbiden, iPlayableService.evStart: self._serviceStarted, iPlayableService.evEOF: self._serviceEOF, }) @@ -826,8 +878,9 @@ class HbbTVWindow(Screen, InfoBarNotifications): seek = service and service.seek() l = seek.getLength() p = seek.getPlayPosition() - #return (p[1]/90000, l[1]/90000) - return (p[1], l[1]) + if(not l[0] and not p[0]): + return (p[1], l[1]) + return (90000,90000) except: pass return (-1,-1) @@ -841,7 +894,7 @@ class HbbTVWindow(Screen, InfoBarNotifications): self._vod_length = length if position == -1 and length == -1: raise Exception("Can't get play status") - #print getTimeString(position), "/", getTimeString(length) + #print position, "/", length, " - ", getTimeString(position), "/", getTimeString(length) self._ssm.setStatus(position, length, 1) except Exception, ErrMsg: print ErrMsg @@ -861,11 +914,13 @@ class HbbTVWindow(Screen, InfoBarNotifications): self._currentServicePositionTimer.stop() def _layoutFinished(self): + global __gval__ + __gval__.hbbtv_handelr._soft_volume = -1 self.setTitle(_('HbbTV Plugin')) command_util = getCommandUtil() profile = self._profile (sid, onid, tsid, name, orgid) = getChannelInfos() - params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name + params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name if self._use_ait: command_util.sendCommand('OP_HBBTV_UNLOAD_AIT') time.sleep(1) @@ -887,44 +942,37 @@ class HbbTVWindow(Screen, InfoBarNotifications): except Exception, ErrMsg: pass try: if self._cb_close_window in command_server.onHbbTVCloseCB: - command_server.onHbbTVCloseCB.remove(self._cb_close_window) + command_server.onHbbTVCloseCB.remove(self._cb_close_window) except Exception, ErrMsg: pass try: if self._cb_closed_func is not None: self._cb_closed_func() except: pass + restoreResolution() fbClass.getInstance().unlock() eRCInput.getInstance().unlock() self.close() - def _serviceForbiden(self): - global __gval__ - real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl()) - print "Received URI :\n", real_url - - if real_url is not None: - __gval__.hbbtv_handelr.doRetryOpen(real_url.strip()) - def _cb_set_page_title(self, title=None): print "page title :",title if title is None: return self.setTitle(title) -class HbbTVHelper(Screen): - skin = """""" +class HbbTVHelper(Screen, InfoBarNotifications): + skin = """""" def __init__(self, session): global __gval__ __gval__.hbbtv_handelr = HandlerHbbTV(session) __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr) - self._urls = None - #self._stop_opera() - #self._start_opera() - self._restart_opera() - Screen.__init__(self, session) + InfoBarNotifications.__init__(self) + self._session = session + + self._restart_opera() + self._timer_infobar = eTimer() self._timer_infobar.callback.append(self._cb_registrate_infobar) self._timer_infobar.start(1000) @@ -939,43 +987,76 @@ class HbbTVHelper(Screen): _g_ssm_ = SimpleSharedMemory() _g_ssm_.doConnect() + self._callbackStartStop = None + + self.__et = ServiceEventTracker(screen=self, eventmap={ + iPlayableService.evHBBTVInfo: self._cb_detectedAIT, + iPlayableService.evUpdatedInfo: self._cb_updateInfo + }) + self._applicationList = None + + self.mVuplusBox = False + issue = open("/etc/issue").read() + if(issue.startswith("Vuplus")): + self.mVuplusBox = True + + def _cb_detectedAIT(self): + name = self._cb_ready_for_ait() + if name is not None and self.mVuplusBox: + from Screens.InfoBarGenerics import gHbbtvApplication + gHbbtvApplication.setApplicationName(str(name)) + + def _cb_updateInfo(self): + if not self._excuted_browser: + command_util = getCommandUtil() + command_util.sendCommand('OP_HBBTV_UNLOAD_AIT') + if self.mVuplusBox: + from Screens.InfoBarGenerics import gHbbtvApplication + gHbbtvApplication.setApplicationName("") + #self._applicationList = None + def _cb_registrate_infobar(self): if InfoBar.instance: self._timer_infobar.stop() - if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT: - InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait) if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation: InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated) - def _cb_ready_for_ait(self, orgId=0): - if orgId == 0: - if not self._excuted_browser: - command_util = getCommandUtil() - command_util.sendCommand('OP_HBBTV_UNLOAD_AIT') - return + def _cb_ready_for_ait(self): setChannelInfo(None, None, None, None, None) service = self._session.nav.getCurrentService() - info = service and service.info() + info = service and service.info() if info is not None: - sid = info.getInfo(iServiceInformation.sSID) + sid = info.getInfo(iServiceInformation.sSID) onid = info.getInfo(iServiceInformation.sONID) tsid = info.getInfo(iServiceInformation.sTSID) name = info.getName() if name is None: name = "" - orgid = 0 - namelen = len(name) - for x in info.getInfoObject(iServiceInformation.sHBBTVUrl): - if x[0] in (1, -1) : - orgid = x[3] - break - setChannelInfo(sid, onid, tsid, name, orgid) + + pmtid = info.getInfo(iServiceInformation.sPMTPID) + demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId) + + from aitreader import eAITSectionReader + reader = eAITSectionReader(demux, pmtid, sid) + if reader.doOpen(info, self.mVuplusBox): + reader.doParseApplications() + reader.doDump() + else: print "no data!!" + + try: + self._applicationList = reader.getApplicationList() + if len(self._applicationList) > 0: + orgid = int(self._applicationList[0]["orgid"]) + setChannelInfo(sid, onid, tsid, name, orgid) + return self._applicationList[0]["name"] + except: pass + return None def _cb_hbbtv_activated(self, title=None, url=None): if not self._is_browser_running(): message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.") - self.session.open(MessageBox, message, MessageBox.TYPE_INFO) + self._session.open(MessageBox, message, MessageBox.TYPE_INFO) return service = self._session.nav.getCurrentlyPlayingServiceReference() setBeforeService(service) @@ -999,9 +1080,9 @@ class HbbTVHelper(Screen): time.sleep(2) setNeedRestart(False) - for x in self._urls: - control_code = x[0] - tmp_url = x[2] + for x in self._applicationList: + control_code = int(x["control"]) + tmp_url = x["url"] if tmp_url == url and control_code == 1: use_ait = True self._excuted_browser = True @@ -1013,50 +1094,57 @@ class HbbTVHelper(Screen): def _start_opera(self): if not self._is_browser_running(): global HBBTVAPP_PATH - start_command = '%s/launcher start'%(HBBTVAPP_PATH) + global __gval__ + start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY) os.system(start_command) + return True def _stop_opera(self): global HBBTVAPP_PATH try: os.system('%s/launcher stop'%(HBBTVAPP_PATH)) except: pass + return True def _restart_opera(self): global HBBTVAPP_PATH - try: os.system('%s/launcher restart'%(HBBTVAPP_PATH)) + global __gval__ + try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)) except: pass + return True def getStartHbbTVUrl(self): - url, self._urls, self._profile = None, None, 0 - service = self._session.nav.getCurrentService() - info = service and service.info() - if not info: return None - self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl) - for u in self._urls: - if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code - url = u[2] - self._profile = u[5] + url, self._profile = None, 0 + if self._applicationList is not None: + for u in self._applicationList: + if u["control"] in (1, -1): + url = u["url"] + self._profile = u["profile"] if url is None: - url = info.getInfoString(iServiceInformation.sHBBTVUrl) + service = self._session.nav.getCurrentService() + info = service and service.info() + if info: + url = info.getInfoString(iServiceInformation.sHBBTVUrl) return url def showApplicationSelectionBox(self): applications = [] if self.getStartHbbTVUrl(): - for x in self._urls: - applications.append((x[1], x)) + for x in self._applicationList: + applications.append((x["name"], x)) else: applications.append((_("No detected HbbTV applications."), None)) self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications) def _application_selected(self, selected): + print selected try: if selected[1] is None: return - self._cb_hbbtv_activated(selected[1][1], selected[1][2]) + self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"]) except Exception, ErrMsg: print ErrMsg - def showBrowserConfigBox(self): + def showBrowserConfigBox(self, callback=None): start_stop_mode = [] + self._callbackStartStop = callback if self._is_browser_running(): start_stop_mode.append((_('Stop'),'Stop')) else: start_stop_mode.append((_('Start'),'Start')) @@ -1065,6 +1153,8 @@ class HbbTVHelper(Screen): def _browser_config_selected(self, selected): if selected is None: return + if self._callbackStartStop is not None: + self._callbackStartStop() try: mode = selected[1] if mode == 'Start': @@ -1089,7 +1179,7 @@ class HbbTVHelper(Screen): return False serviceList = eServiceCenter.getInstance().list(root) if serviceList is None: - return False + return False while True: service = serviceList.getNext() if service is None or not service.valid(): @@ -1103,7 +1193,7 @@ class HbbTVHelper(Screen): if len(serviceRefItems) < 5: continue - sid = serviceRefItems[3] + sid = serviceRefItems[3] tsid = serviceRefItems[4] if sid == _sid and tsid == _tsid: self._session.nav.playService(eServiceReference(serviceRef)) @@ -1116,7 +1206,7 @@ class OperaBrowserSetting: def __init__(self): self._settingFileName = '/usr/local/hbb-browser/home/setting.ini' self._start = None - self._type = None + self._type = None self._keymap = None self._read() def _read(self): @@ -1151,8 +1241,8 @@ class OperaBrowserSetting: } class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): - skin= """ - + skin = """ + @@ -1163,27 +1253,27 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): """ - def __init__(self, session, currentUrl): - self.session = session + def __init__(self, session, currentUrl): + self.session = session Screen.__init__(self, session) self.menulist = [] ConfigListScreen.__init__(self, self.menulist) self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], { - "red" : self.keyRed, - "green" : self.keyGreen, - "ok" : self.keyOK, + "red" : self.keyRed, + "green" : self.keyGreen, + "ok" : self.keyOK, "cancel" : self.keyRed - }, -2) - self["key_red"] = StaticText(_("Cancel")) + }, -2) + self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) - self["url"] = Label() + self["url"] = Label() self._currentPageUrl = currentUrl if self._currentPageUrl is None: self._currentPageUrl = '' - self._startPageUrl = None + self._startPageUrl = None self._keymapType = None self.makeMenuEntry() self.onLayoutFinish.append(self.layoutFinished) @@ -1248,8 +1338,8 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): if not strIsEmpty(self._currentPageUrl): l.append(("current", _("Current Page"))) l.append(("direct", _("Direct Input"))) - self.menuItemStartpage = ConfigSelection(default="startpage", choices = l) - self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage) + self.menuItemStartpage = ConfigSelection(default="startpage", choices = l) + self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage) kl = self.getKeymapTypeList() @@ -1277,7 +1367,7 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): class BookmarkEditWindow(ConfigListScreen, Screen): CATEGORY,BOOKMARK = 0,1 - skin= """ + skin = """ @@ -1295,7 +1385,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): self.mMode = _mode self.mType = _type self.mData = _data - self.mSession = session + self.mSession = session self.mBookmarkManager = _bm if _data is not None: @@ -1307,14 +1397,14 @@ class BookmarkEditWindow(ConfigListScreen, Screen): ConfigListScreen.__init__(self, self.menulist) self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], { - "ok" : self.keyGreen, - "green" : self.keyGreen, - "red" : self.keyRed, + "ok" : self.keyGreen, + "green" : self.keyGreen, + "red" : self.keyRed, "cancel" : self.keyRed, - }, -2) + }, -2) - self["VKeyIcon"] = Pixmap() - self["key_red"] = StaticText(_("Cancel")) + self["VKeyIcon"] = Pixmap() + self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self.menuItemTitle = None @@ -1343,7 +1433,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): return None def showMessageBox(self, text): - msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "." + msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the") + " " + text + "." self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO) return False @@ -1380,7 +1470,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): else: if self.mMode == _('Add'): bookmarkTitle = self.menuItemTitle.value - bookmarkUrl = self.menuItemUrl.value + bookmarkUrl = self.menuItemUrl.value if strIsEmpty(bookmarkTitle): self["config"].setCurrentIndex(0) return self.showMessageBox(_("Bookmark Title")) @@ -1396,7 +1486,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): self["config"].setCurrentIndex(1) return self.showMessageBox(_("Bookmark URL")) self.mData.mTitle = self.menuItemTitle.value - self.mData.mUrl = self.menuItemUrl.value + self.mData.mUrl = self.menuItemUrl.value self.mBookmarkManager.updateBookmark(self.mData) return True @@ -1416,7 +1506,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): if self.mType == BookmarkEditWindow.CATEGORY: self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False) - self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName) + self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName) self.menulist.append(self.menuEntryName) else: @@ -1424,17 +1514,17 @@ class BookmarkEditWindow(ConfigListScreen, Screen): self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False) self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle) - self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl) + self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl) self.menulist.append(self.menuEntryTitle) self.menulist.append(self.menuEntryUrl) - + self["config"].list = self.menulist self["config"].l.setList(self.menulist) class OperaBrowserBookmarkWindow(Screen): - skin = """ - + skin = """ + @@ -1453,7 +1543,7 @@ class OperaBrowserBookmarkWindow(Screen): """ def __init__(self, _session, _url=None, _title=None): - self.mUrl = _url + self.mUrl = _url self.mTitle = _title self.mBookmarkManager = BookmarkManager.getInstance() self.mSession = _session @@ -1462,10 +1552,10 @@ class OperaBrowserBookmarkWindow(Screen): "ok" : self.keyOK, "cancel": self.keyCancel, "red" : self.keyRed, - "green" : self.keyGreen, + "green" : self.keyGreen, "yellow": self.keyYellow, "blue" : self.keyBlue, - "0" : self.keyNumber, + "0" : self.keyNumber, },-2) self["key_red"] = StaticText(_("Exit")) @@ -1496,7 +1586,7 @@ class OperaBrowserBookmarkWindow(Screen): self.mBookmarkList = self.setBookmarkList() self["bookmarklist"].setList(self.mBookmarkList) def cbEditWindow(self, ret=False): - if not ret: + if not ret: return self.updateBookmarkList() def getParentCategory(self): @@ -1598,8 +1688,8 @@ class OperaBrowserBookmarkWindow(Screen): class BrowserHelpWindow(Screen, HelpableScreen): MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3 - skin = """ - + skin = """ + @@ -1609,10 +1699,10 @@ class BrowserHelpWindow(Screen, HelpableScreen): - + """ - def __init__(self, session): - Screen.__init__(self, session) + def __init__(self, session): + Screen.__init__(self, session) HelpableScreen.__init__(self) self["key_red"] = StaticText(_("Exit")) @@ -1624,7 +1714,7 @@ class BrowserHelpWindow(Screen, HelpableScreen): "ok" : self.keyRed, "cancel": self.keyRed, "red" : self.keyRed, - "green" : self.keyGreen, + "green" : self.keyGreen, "yellow": self.keyYellow, "blue" : self.keyBlue, },-2) @@ -1714,22 +1804,33 @@ class OperaBrowser(Screen): SUBMENULIST_HEIGHT = 25 SUBMENULIST_NEXT = 2 + # menulist->position->y : MENUBAR_ITEM_HEIGHT+30 + # menulist->size->x : SUBMENULIST_WIDTH + # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT + # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30 + # submenulist->size->x : SUBMENULIST_WIDTH + + size = getDesktop(0).size() + WIDTH = int(size.width()) + HEIGHT = int(size.height()) skin = """ - + - - - - - """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)# modify menu - - MENUITEMS_LIST =[[(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)], - [(_('Bookmark'), None), (_('Preference'), None)], - [(_('About'), None), (_('Help'), None)]] - def __init__(self, session, url=None): + + + + + """ % { 'width' :WIDTH, + 'height' :HEIGHT, + 'bottom_pos_y' :HEIGHT-80, + 'bottom_size_x' :WIDTH } + + COMMAND_MAP = {} + MENUITEMS_LIST =[] + def __init__(self, session, url=None, isWebAppMode=False): Screen.__init__(self, session) self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], { "cancel" : self.keyCancel @@ -1741,6 +1842,8 @@ class OperaBrowser(Screen): ,"menu" : self.keyMenu }, -2) + self.UpdateLanguageCB() + self._terminatedBrowser = True self._enableKeyEvent = True self._currentPageUrl = None @@ -1770,6 +1873,25 @@ class OperaBrowser(Screen): self._onCloseTimer.callback.append(self._cb_onClose) self.paramUrl = url + self.paramIsWebAppMode = isWebAppMode + language.addCallback(self.UpdateLanguageCB) + + def UpdateLanguageCB(self): + # modify menu + self.MENUITEMS_LIST = [ + [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)], + [(_('Bookmark'), None), (_('Preference'), None)], + [(_('About'), None), (_('Help'), None)]] + self.COMMAND_MAP = {} + self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit + self.COMMAND_MAP[_('Help')] = self._cmd_on_Help + self.COMMAND_MAP[_('About')] = self._cmd_on_About + self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl + self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop + self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark + self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference + self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser + self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage def enableRCMouse(self, mode): #mode=[0|1]|[False|True] rcmouse_path = "/proc/stb/fp/mouse" @@ -1790,7 +1912,9 @@ class OperaBrowser(Screen): if self.paramUrl is not None: self.keyMenu() - self.cbUrlText(self.paramUrl, 1) + if self.paramIsWebAppMode: + self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV') + else: self.cbUrlText(data=self.paramUrl, mode=1) def selectMenuitem(self): tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu @@ -1809,7 +1933,7 @@ class OperaBrowser(Screen): l = self.MENUITEMS_LIST[self.menubarCurrentIndex] if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running l = [(_('Return'), None)] - self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex] + self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex] return self.lvMenuItems def setSubListOnView(self): @@ -1851,7 +1975,7 @@ class OperaBrowser(Screen): command_server = getCommandServer() try: if self._on_close_window in command_server.onHbbTVCloseCB: - command_server.onHbbTVCloseCB.remove(self._on_close_window) + command_server.onHbbTVCloseCB.remove(self._on_close_window) except Exception, ErrMsg: pass try: if self._on_setPageTitle in command_server.onSetPageTitleCB: @@ -1860,12 +1984,14 @@ class OperaBrowser(Screen): self._on_setPageTitle(_('Opera Browser')) self.enableRCMouse(False) self.toggleMainScreen() + restoreResolution() fbClass.getInstance().unlock() eRCInput.getInstance().unlock() self._terminatedBrowser = True self._enableKeyEvent = True #if not self.toggleListViewFlag: # self.keyDown() + self._currentPageUrl = '' if self.paramUrl is not None: self.keyCancel() @@ -1879,25 +2005,35 @@ class OperaBrowser(Screen): return self.setTitle(title) - def cbUrlText(self, data=None, mode=0): + def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'): + global _g_helper + if not _g_helper._is_browser_running(): + return print "Inputed Url :", data, mode if strIsEmpty(data): return #self.hideSubmenu() command_server = getCommandServer() if self._on_setPageTitle not in command_server.onSetPageTitleCB: - command_server.onSetPageTitleCB.append(self._on_setPageTitle) + command_server.onSetPageTitleCB.append(self._on_setPageTitle) if self._on_close_window not in command_server.onHbbTVCloseCB: command_server.onHbbTVCloseCB.append(self._on_close_window) self.toggleMainScreen() self.enableRCMouse(True) + fbClass.getInstance().lock() eRCInput.getInstance().lock() + + #setResolution(1280, 720) + command_util = getCommandUtil() - command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode) + command_util.sendCommand(opcode, data, mode) self._terminatedBrowser = False self._enableKeyEvent = False + global __gval__ + __gval__.hbbtv_handelr._soft_volume = -1 + def _on_close_window(self): self._onCloseTimer.start(1000) @@ -1905,6 +2041,11 @@ class OperaBrowser(Screen): if data is None: return (url, mode) = data + global _g_helper + if not _g_helper._is_browser_running(): + message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.") + self.session.open(MessageBox, message, MessageBox.TYPE_INFO) + return self.cbUrlText(url, mode) def _cmd_on_OpenUrl(self): @@ -1918,11 +2059,14 @@ class OperaBrowser(Screen): self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO) def _cmd_on_Exit(self): self.close() + def _cb_cmdOnStartSTop(self): + self.keyMenu() def _cmd_on_StartStop(self): global _g_helper if _g_helper is None: return - _g_helper.showBrowserConfigBox() + _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop) + def _cmd_on_Bookmark(self): url = self._currentPageUrl if url is None: @@ -1957,22 +2101,14 @@ class OperaBrowser(Screen): self.session.open(BrowserHelpWindow) def doCommand(self, command): - # modify menu - cmd_map = {} - cmd_map[_('Exit')] = self._cmd_on_Exit - cmd_map[_('Help')] = self._cmd_on_Help - cmd_map[_('About')] = self._cmd_on_About - cmd_map[_('Open URL')] = self._cmd_on_OpenUrl - cmd_map[_('Start/Stop')] = self._cmd_on_StartStop - cmd_map[_('Bookmark')] = self._cmd_on_Bookmark - cmd_map[_('Preference')] = self._cmd_on_Preference - cmd_map[_('Return')] = self._cmd_on_ReturnToBrowser - cmd_map[_('Open Startpage')] = self._cmd_on_OpenStartpage try: - cmd_map[command]() + self.COMMAND_MAP[command]() except Exception, ErrMsg: print ErrMsg def keyOK(self): + if not self.toggleMainScreenFlag: + self.keyMenu() + return if not self.toggleListViewFlag: self.keyDown() return @@ -2056,6 +2192,7 @@ class OperaBrowser(Screen): #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="") fbClass.getInstance().lock() eRCInput.getInstance().lock() + #setResolution(1280, 720) if self.toggleListViewFlag: self.toggleMainScreen() self._currentPageUrl = None @@ -2084,6 +2221,153 @@ class OperaBrowser(Screen): self.currentListView.pageUp() self.keyUp() +config.plugins.youtubetv = ConfigSubsection() +config.plugins.youtubetv.showhelp = ConfigYesNo(default = False) +config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False) +class YoutubeTVWindow(Screen, HelpableScreen): + skin = """ + + + + + + + + + + """ + def __init__(self, session): + Screen.__init__(self, session) + HelpableScreen.__init__(self) + + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], { + "cancel": self.keyCancel, + "red" : self.keyCancel, + "green" : self.keyGreen, + "yellow": self.keyYellow, + },-2) + + self["key_green"] = StaticText(_("Start")) + self["key_yellow"] = StaticText(_("Help")) + + self["infomation"] = Label() + self["startdesc"] = Label() + self["helpdesc"] = Label() + + self.onLayoutFinish.append(self.layoutFinished) + + def layoutFinished(self): + self.setTitle(_('Start YouTube TV')) + self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+")) + self["startdesc" ].setText(_("* Start YouTube TV")) + self["helpdesc" ].setText(_("* RC Help")) + + def setHelpModeActions(self): + self.helpList = [] + self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", { + "ok" : (self.keyPass, _("Play ther selected the video")), + "cancel": (self.keyPass, _("Exit the YouTube TV")), + }) + self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", { + "pageUp" : (self.keyPass, _("Move up")), + "pageDown" : (self.keyPass, _("Move down")), + "prevEvent" : (self.keyPass, _("Move left")), + "nextEvent" : (self.keyPass, _("Move right")), + }) + self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", { + "info" : (self.keyPass, _("Search a video")), + "nextService" : (self.keyPass, _("Skip forward 10 sec")), + "prevService" : (self.keyPass, _("Skip backward 10 sec")), + }) + self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", { + "play" : (self.keyPass, _("Play current video")), + "pause" : (self.keyPass, _("Pause current video")), + "stop" : (self.keyPass, _("Stop current video")), + }) + self["ColorActions"] = HelpableActionMap(self, "ColorActions", { + "red" : (self.keyPass, _("Back")), + }) + self.showHelp() + + def keyPass(self): + pass + def keyCancel(self): + config.plugins.youtubetv.showhelp.cancel() + self.close(False) + def keyGreen(self): + config.plugins.youtubetv.showhelp.save() + config.plugins.youtubetv.save() + config.plugins.save() + self.close(True) + def keyYellow(self): + self.setHelpModeActions() + def keyBlue(self): + if config.plugins.youtubetv.showhelp.value == True : + config.plugins.youtubetv.showhelp.setValue(False) + else: config.plugins.youtubetv.showhelp.setValue(True) + +class YoutubeTVSettings(ConfigListScreen, Screen): + skin= """ + + + + + + + + + + """ + def __init__(self, session): + self.session = session + Screen.__init__(self, session) + + self.menulist = [] + ConfigListScreen.__init__(self, self.menulist) + + self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], { + "ok" : self.keyGreen, + "green" : self.keyGreen, + "red" : self.keyRed, + "cancel" : self.keyRed, + }, -2) + + self["key_red"] = StaticText(_("Cancel")) + self["key_green"] = StaticText(_("Save")) + + self.makeConfigList() + self.onLayoutFinish.append(self.layoutFinished) + + def layoutFinished(self): + self.setTitle(_('YouTube TV Settings')) + + def keyGreen(self): + config.plugins.youtubetv.showhelp.save() + config.plugins.youtubetv.uri.save() + config.plugins.youtubetv.save() + config.plugins.save() + self.close() + def keyRed(self): + config.plugins.youtubetv.showhelp.cancel() + config.plugins.youtubetv.uri.cancel() + self.close() + + def keyLeft(self): + ConfigListScreen.keyLeft(self) + + def keyRight(self): + ConfigListScreen.keyRight(self) + + def makeConfigList(self): + self.menulist = [] + entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri) + entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Starter again"), config.plugins.youtubetv.showhelp) + self.menulist.append(entryUri) + self.menulist.append(entryShowHelp) + + self["config"].list = self.menulist + self["config"].l.setList(self.menulist) + def auto_start_main(reason, **kwargs): if reason: command_server = getCommandServer() @@ -2093,6 +2377,11 @@ from Screens.HelpMenu import HelpableScreen def session_start_main(session, reason, **kwargs): fbClass.getInstance().unlock() eRCInput.getInstance().unlock() + + from enigma import getDesktop + desktopSize = getDesktop(0).size() + setDefaultResolution(desktopSize.width(), desktopSize.height()) + global _g_helper _g_helper = session.open(HbbTVHelper) @@ -2105,7 +2394,7 @@ def HelpableScreen__init__(self): self["helpActions"] = ActionMap(["HelpbuttonActions"], { "help_b" : self.showHelp, - "help_l" : self.showManual, + "help_l" : self.showManual, }, -2) _g_clearBrowserDataTimer = eTimer() @@ -2125,11 +2414,50 @@ def showManual(self): try: _g_clearBrowserDataTimer.callback.remove(_do_clean) except: pass setPluginBrowser(None) + def clearBrowserData(): _g_clearBrowserDataTimer.callback.append(_do_clean) _g_clearBrowserDataTimer.start(50) setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url)) +_g_backupSession = None +def showYoutubeTV(session, **kwargs): + def _do_clean(): + _g_clearBrowserDataTimer.stop() + try: _g_clearBrowserDataTimer.callback.remove(_do_clean) + except: pass + setPluginBrowser(None) + global _g_backupSession + + service = getBeforeService() + if service is not None: + _g_backupSession.nav.playService(eServiceReference(service)) + _g_backupSession = None + def clearBrowserData(): + _g_clearBrowserDataTimer.callback.append(_do_clean) + _g_clearBrowserDataTimer.start(50) + def cbYoutubeTVClose(ret): + if ret: + global _g_backupSession + _g_backupSession = session + service = session.nav.getCurrentlyPlayingServiceReference() + if service is not None: + setBeforeService(service.toString()) + session.nav.stopService() + else: setBeforeService(service) + setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True)) + if config.plugins.youtubetv.showhelp.value == True: + cbYoutubeTVClose(True) + else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow) + +def youtube_setting_main(session, **kwargs): + session.open(YoutubeTVSettings) + +def start_menu_main(menuid, **kwargs): + if menuid == "mainmenu": + return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)] + return [] + def plugin_start_main(session, **kwargs): #session.open(OperaBrowser) def _do_clean(): @@ -2144,19 +2472,21 @@ def plugin_start_main(session, **kwargs): def plugin_extension_start_application(session, **kwargs): global _g_helper - if _g_helper is None: + if _g_helper is None: return _g_helper.showApplicationSelectionBox() def plugin_extension_browser_config(session, **kwargs): global _g_helper - if _g_helper is None: + if _g_helper is None: return _g_helper.showBrowserConfigBox() def Plugins(path, **kwargs): l = [] l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main)) + l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main)) + l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main)) l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10)) l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application)) l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))