X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FPlugins%2FExtensions%2FHbbTV%2Fplugin.py;h=70a2ec32e3994b5042930f8059394f2615d0da83;hp=56db6d850696d6a27cc5a27a6d53ae33391fc2b3;hb=dc145d86c6e4767a070809885b0f9e1307dfd6ed;hpb=8c714bd3d208e4b555f53e08f7626b40390a0d23;ds=sidebyside diff --git a/lib/python/Plugins/Extensions/HbbTV/plugin.py b/lib/python/Plugins/Extensions/HbbTV/plugin.py index 56db6d8..70a2ec3 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 @@ -136,54 +171,6 @@ 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_ = { @@ -216,10 +203,15 @@ class OpCodeSet: ,"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" @@ -251,10 +243,15 @@ class OpCodeSet: ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE" ,0x030E : "OP_BROWSER_MENU_REQ" ,0x030F : "OP_BROWSER_MENU_RES" + ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP" ,0x0401 : "OP_DVBAPP_VOL_UP" ,0x0402 : "OP_DVBAPP_VOL_DOWN" + ,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): @@ -462,6 +459,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 @@ -469,6 +467,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 @@ -479,6 +479,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 @@ -516,6 +518,20 @@ 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 @@ -530,6 +546,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() @@ -573,10 +590,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): @@ -641,16 +661,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): @@ -673,7 +718,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: @@ -708,6 +753,8 @@ class HandlerHbbTV(Handler): 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): @@ -738,7 +785,8 @@ 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: @@ -783,13 +831,13 @@ class HbbTVWindow(Screen, InfoBarNotifications): """ 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, }) @@ -824,8 +872,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) @@ -853,9 +902,14 @@ class HbbTVWindow(Screen, InfoBarNotifications): print ErrMsg def _serviceEOF(self): + (position,length) = self.getVodPlayTime() + self._ssm.setStatus(length, length, 1) + print "service EOF" self._currentServicePositionTimer.stop() def _layoutFinished(self): + global __gval__ + __gval__.hbbtv_handelr._soft_volume = -1 self.setTitle(_('HbbTV Plugin')) command_util = getCommandUtil() profile = self._profile @@ -888,38 +942,31 @@ class HbbTVWindow(Screen, InfoBarNotifications): 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): +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) @@ -934,20 +981,41 @@ 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() @@ -959,18 +1027,30 @@ class HbbTVHelper(Screen): 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) @@ -994,9 +1074,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 @@ -1008,8 +1088,10 @@ 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 @@ -1018,20 +1100,19 @@ class HbbTVHelper(Screen): 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: + self._profile = self._applicationList[0]["profile"] + url = self._applicationList[0]["url"] if url is None: + service = self._session.nav.getCurrentService() + info = service and service.info() url = info.getInfoString(iServiceInformation.sHBBTVUrl) return url @@ -1039,19 +1120,21 @@ class HbbTVHelper(Screen): 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')) @@ -1060,6 +1143,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': @@ -1112,6 +1197,7 @@ class OperaBrowserSetting: self._settingFileName = '/usr/local/hbb-browser/home/setting.ini' self._start = None self._type = None + self._keymap = None self._read() def _read(self): f = open(self._settingFileName) @@ -1122,26 +1208,31 @@ class OperaBrowserSetting: if len(tmp) > 1: self._type = int(tmp[1]) else: self._type = 0 + elif line.startswith('keymap='): + self._keymap = line[7:len(line)-1] f.close() def _write(self): tmpstr = [] tmpstr.append('start=%s %d\n' % (self._start, self._type)) + tmpstr.append('keymap=%s\n' % (self._keymap)) f = open(self._settingFileName, 'w') f.writelines(tmpstr) f.close() - def setData(self, start, types=0): + def setData(self, start, types=0, keymap="us-rc"): self._start = start self._type = types + self._keymap = keymap self._write() def getData(self): return { 'start':self._start, 'type':self._type, + 'keymap':self._keymap, } class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): skin= """ - + @@ -1173,18 +1264,12 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): if self._currentPageUrl is None: self._currentPageUrl = '' self._startPageUrl = None - + self._keymapType = None self.makeMenuEntry() self.onLayoutFinish.append(self.layoutFinished) def layoutFinished(self): self.setTitle(_('Preference')) - try: - d = OperaBrowserSetting().getData() - self._startPageUrl = d['start'] - #d['type'] - except: self._startPageUrl = 'http://vuplus.com' - self.updateStartPageUrl() def updateStartPageUrl(self): if self.menuItemStartpage.value == "startpage": @@ -1202,7 +1287,10 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): mode = 0 if url.find('/usr/local/manual') > 0: mode = 1 - OperaBrowserSetting().setData(url, mode) + self._keymapType = self.menuItemKeyboardLayout.value + OperaBrowserSetting().setData(url, mode, self._keymapType) + command_util = getCommandUtil() + command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP') self.close() def keyRed(self): @@ -1224,6 +1312,16 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): ConfigListScreen.keyRight(self) self.updateStartPageUrl() + def getKeymapTypeList(self): + types = [] + for f in os.listdir("/usr/local/hbb-browser/keymap"): + filesplit = f.split('.') + if len(filesplit) < 2: + continue + types.append((filesplit[1], filesplit[1])) + types.sort() + return types + def makeMenuEntry(self): l = [] l.append(("startpage", _("Start Page"))) @@ -1232,11 +1330,27 @@ class OperaBrowserPreferenceWindow(ConfigListScreen, Screen): l.append(("direct", _("Direct Input"))) self.menuItemStartpage = ConfigSelection(default="startpage", choices = l) self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage) + + kl = self.getKeymapTypeList() + + try: + d = OperaBrowserSetting().getData() + self._startPageUrl = d['start'] + self._keymapType = d['keymap'] + #d['type'] + except: self._startPageUrl = 'http://vuplus.com' + self.updateStartPageUrl() + + if self._keymapType is None or len(self._keymapType) == 0: + self._keymapType = "us-rc" + self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl) + self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout) self.resetMenuList() def resetMenuList(self): self.menulist = [] self.menulist.append(self.menuEntryStartpage) + self.menulist.append(self.menuEntryKeyboardLayout) self["config"].list = self.menulist self["config"].l.setList(self.menulist) @@ -1400,7 +1514,7 @@ class BookmarkEditWindow(ConfigListScreen, Screen): class OperaBrowserBookmarkWindow(Screen): skin = """ - + @@ -1680,22 +1794,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 @@ -1707,6 +1832,8 @@ class OperaBrowser(Screen): ,"menu" : self.keyMenu }, -2) + self.UpdateLanguageCB() + self._terminatedBrowser = True self._enableKeyEvent = True self._currentPageUrl = None @@ -1736,6 +1863,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" @@ -1756,7 +1902,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 @@ -1826,12 +1974,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() @@ -1845,7 +1995,10 @@ 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 @@ -1857,13 +2010,20 @@ class OperaBrowser(Screen): 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) @@ -1871,6 +2031,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): @@ -1884,11 +2049,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: @@ -1923,22 +2091,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 @@ -2022,6 +2182,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 @@ -2050,6 +2211,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 Stater 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() @@ -2059,6 +2367,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) @@ -2096,6 +2409,44 @@ def showManual(self): _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(): @@ -2123,6 +2474,8 @@ def plugin_extension_browser_config(session, **kwargs): 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))