from Plugins.Plugin import PluginDescriptor
-
from Screens.Screen import Screen
from Screens.InfoBar import InfoBar
from Screens.ChoiceBox import ChoiceBox
+from Screens.HelpMenu import HelpableScreen
from Screens.MessageBox import MessageBox
-from Screens.InfoBarGenerics import InfoBarNotifications
from Screens.VirtualKeyBoard import VirtualKeyBoard
-
-from Components.PluginComponent import plugins
-from Components.Button import Button
-from Components.Label import Label
-from Components.Sources.StaticText import StaticText
-from Components.ActionMap import NumberActionMap, ActionMap
+from Components.config import config
+from Components.ActionMap import ActionMap
+from Components.Language import language
from Components.ServiceEventTracker import ServiceEventTracker
-from Components.MenuList import MenuList
-from Components.Label import Label, MultiColorLabel
-from Components.ConfigList import ConfigListScreen
from Components.VolumeControl import VolumeControl
-from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue
-
-from enigma import eTimer, eConsoleAppContainer, getDesktop, eServiceReference, iPlayableService, iServiceInformation, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, getPrevAsciiCode, eRCInput, fbClass
-
-import os, struct, threading, stat, select, time, socket, select
-
-strIsEmpty = lambda x: x is None or len(x) == 0
-
-HBBTVAPP_PATH = "/usr/local/hbb-browser"
-COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
-
-class GlobalValues:
- command_util = None
- command_server = None
-
- before_service = None
-
- channel_info_sid = None
- channel_info_onid = None
- channel_info_tsid = None
- channel_info_name = None
- channel_info_orgid = None
-
- hbbtv_handelr = None
-
- packet_m = 0xBBADBEE
- packet_h = '!IIII'
- packet_hl = struct.calcsize(packet_h)
-
- need_restart = False
-__gval__ = GlobalValues()
-
-def getPacketHeaders():
- global __gval__
- 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;
- global __gval__
- __gval__.channel_info_sid = sid
- __gval__.channel_info_onid = onid
- __gval__.channel_info_tsid = tsid
- __gval__.channel_info_name = name
- __gval__.channel_info_orgid = 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,
- __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,
- __gval__.channel_info_orgid)
-
-def isNeedRestart():
- global __gval__
- print "Need Restart(GET) : ", __gval__.need_restart
- return __gval__.need_restart
-def setNeedRestart(n):
- global __gval__
- __gval__.need_restart = n
- print "Need Restart(SET) : ", __gval__.need_restart
-
-def getCommandUtil():
- global __gval__
- return __gval__.command_util
-def getCommandServer():
- global __gval__
- return __gval__.command_server
-
-def setBeforeService(s):
- global __gval__
- __gval__.before_service = s
-def getBeforeService():
- global __gval__
- return __gval__.before_service
-
-def _unpack(packed_data):
- (mg, h, hlen) = getPacketHeaders()
-
- if strIsEmpty(packed_data):
- return None
- (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
- if m != mg:
- return None
- d = 0
- if l > 0:
- d = packed_data[hlen:hlen+l]
- return (o,d,s)
-
-def _pack(opcode, params=None, reserved=0):
- (m, h, hlen) = getPacketHeaders()
- if strIsEmpty(params):
- params = ''
- 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_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_BROWSER_OPEN_URL" : 0x0301
- ,"OP_DVBAPP_VOL_UP" : 0x0401
- ,"OP_DVBAPP_VOL_DOWN" : 0x0402
- ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
- ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
- }
- self._opstr_ = {
- 0x0000 : "OP_UNKNOWN"
- ,0x0001 : "OP_HBBTV_EXIT"
- ,0x0002 : "OP_HBBTV_OPEN_URL"
- ,0x0003 : "OP_HBBTV_LOAD_AIT"
- ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
- ,0x0005 : "OP_HBBTV_FULLSCREEN"
- ,0x0006 : "OP_HBBTV_TITLE"
- ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
- ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
- ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
- ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
- ,0x0201 : "OP_VOD_URI"
- ,0x0202 : "OP_VOD_PLAY"
- ,0x0203 : "OP_VOD_STOP"
- ,0x0204 : "OP_VOD_PAUSE"
- ,0x0205 : "OP_VOD_STATUS"
- ,0x0206 : "OP_VOD_FORBIDDEN"
- ,0x0207 : "OP_VOD_STOPED"
- ,0x0301 : "OP_BROWSER_OPEN_URL"
- ,0x0401 : "OP_DVBAPP_VOL_UP"
- ,0x0402 : "OP_DVBAPP_VOL_DOWN"
- ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
- ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
- }
-
- def get(self, opstr):
- try:
- return self._opcode_[opstr]
- except: pass
- return self._opcode_["OP_UNKNOWN"]
+from enigma import eTimer, fbClass, eRCInput, iServiceInformation, iPlayableService
- def what(self, opcode):
- try:
- return self._opstr_[opcode]
- except: pass
- return self._opstr_["0x0000"]
-
-class SocketParams:
- def __init__(self):
- self.protocol = None
- self.type = None
- self.addr = None
- self.buf_size = 4096
- 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._buf_size = params.buf_size
- self._handler = params.handler
- self._timeout = params.timeout
- self._destroy = params.destroy
-
- self._terminated = False
- self._server_thread = None
-
- self.onHbbTVCloseCB = []
- self.onSetPageTitleCB = []
-
- def __del__(self):
- if self._destroy is not None:
- self._destroy(self._addr)
-
- def stop(self):
- self._terminated = True
- if self._server_thread is not None:
- self._server_thread.join()
- self._server_thread = None
-
- def start(self):
- self._socket = socket.socket(self._protocol, self._type)
- self._socket.settimeout(self._timeout)
- self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
- self._socket.bind(self._addr)
- self._socket.listen(True)
-
- self._server_thread = threading.Thread(target=self._listen)
- self._server_thread.start()
-
- def _listen(self):
- select_list = [self._socket]
- def _accept():
- try:
- conn, addr = self._socket.accept()
- self._client(conn, addr)
- except Exception, ErrMsg:
- print "ServerSocket Error >>", ErrMsg
- pass
+import os, struct, vbcfg
- while not self._terminated:
- readable, writable, errored = select.select(select_list, [], [], self._timeout)
- for s in readable:
- if s is self._socket:
- _accept()
+from __init__ import _
+from hbbtv import HbbTVWindow
+from browser import Browser
+from youtube import YoutubeTVWindow, YoutubeTVSettings
+from vbipc import VBController, VBServerThread, VBHandlers
- def _client(self, conn, addr):
- try:
- 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:
- try: conn.close()
- except:pass
- if self._handler is not None:
- self._handler.printError(ErrMsg)
- def _send(self, conn, data) :
- conn.send(data)
- conn.close()
-
-class ServerFactory:
- def doListenUnixTCP(self, name, handler):
- def destroy(name):
- if os.path.exists(name):
- os.unlink(name)
- print "Removed ", name
- destroy(name)
-
- params = SocketParams()
- params.protocol = socket.AF_UNIX
- params.type = socket.SOCK_STREAM
- params.addr = name
- params.handler = handler
- params.destroy = destroy
-
- streamServer = StreamServer(params)
- streamServer.start()
- return streamServer
-
- def doListenInetTCP(self, ip, port, handler):
- print "Not implemented yet!!"
- def doListenUnixDGRAM(self, name, handler):
- print "Not implemented yet!!"
- def doListenInetDGRAM(self, ip, port, handler):
- print "Not implemented yet!!"
-
-class Handler:
- def doUnpack(self, data):
- return _unpack(data)
-
- def doPack(self, opcode, params, reserved=0):
- return _pack(opcode, params, reserved)
-
- def doHandle(self, data, onCloseCB):
- opcode, params = 0x0, 'Invalid Request!!'
- return _pack(opcode, params)
-
- def printError(self, reason):
- print reason
-
-class BrowserCommandUtil(OpCodeSet):
- def __init__(self):
- self._fd = None
- OpCodeSet.__init__(self)
-
- def isConnected(self):
- if self._fd is None:
- return False
- return True
-
- def doConnect(self, filename):
- if not os.path.exists(filename):
- print "File not exists :", filename
- return False
- try:
- self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
- if self._fd is None:
- print "Fail to open file :", filename
- return False
- except Exception, ErrMsg:
- print ErrMsg
- self._fd = None
- return False
- return True
-
- def doDisconnect(self):
- if self._fd is None:
- return
- os.close(self._fd)
- self._fd = None
-
- def doSend(self, command, params=None, reserved=0):
- if self._fd is None:
- print "Pipe was not exists!!"
- return False
- data = ''
- try:
- data = _pack(self.get(command), params, reserved)
- if data is None:
- return False
- os.write(self._fd, data)
- print "Send OK!! :", command
- except: return False
- return True
+strIsEmpty = lambda x: x is None or len(x) == 0
- def sendCommand(self, command, params=None, reserved=0):
- if not self.isConnected():
- global COMMAND_PATH
- self.doConnect(COMMAND_PATH)
- result = self.doSend(command, params, reserved)
- self.doDisconnect()
- return result
+vbcfg.SOCKETFILE = '/tmp/.browser.support'
+vbcfg.CONTROLFILE = '/tmp/.browser.controller'
+_OPCODE_LIST = [
+ 'CONTROL_BACK',
+ 'CONTROL_FORWARD',
+ 'CONTROL_STOP',
+ 'CONTROL_RELOAD',
+ 'CONTROL_OPENURL',
+ 'CONTROL_EXIT',
+ 'CONTROL_TITLE',
+ 'CONTROL_OK',
+ 'CONTROL_OUT_OF_MEMORY',
+ 'CONTROL_INVALIDATE',
+ 'CONTROL_GET_FBSIZE',
+ 'CONTROL_GET_VOLUME',
+ 'CONTROL_SET_VOLUME',
+ 'CONTROL_VOLUME_UP',
+ 'CONTROL_VOLUME_DOWN',
+ 'HBBTV_LOADAIT',
+ 'HBBTV_OPENURL',
+ 'YOUTUBETV_OPENURL',
+ 'BROWSER_OPENURL',
+ 'BROWSER_MENU_OPEN',
+ 'BROWSER_MENU_CLOSE',
+ 'BROWSER_VKB_OPEN',
+ 'BROWSER_VKB_CLOSE',
+ 'OOIF_GET_CURRENT_CHANNEL',
+ 'OOIF_BROADCAST_PLAY',
+ 'OOIF_BROADCAST_STOP',
+ 'OOIF_BROADCAST_CHECK',
+ 'CONTROL_RELOAD_KEYMAP',
+ 'OPCODE_END'
+ ]
-class HandlerHbbTV(Handler):
- _vod_service = None
+class VBHandler(VBHandlers):
def __init__(self, session):
self._session = session
- self.opcode = OpCodeSet()
- self.handle_map = {
- 0x0001 : self._cb_handleCloseHbbTVBrowser
- ,0x0006 : self._cb_handleSetPageTitle
- ,0x0009 : self._cb_handleHbbTVRetryOpen
- ,0x0101 : self._cb_handleGetChannelInfoForUrl
- ,0x0102 : self._cb_handleGetChannelInfoForAIT
- ,0x0103 : self._cb_handleGetChannelInfoList
- ,0x0201 : self._cb_handleVODPlayerURI
- ,0x0202 : self._cb_handleVODPlayerPlay
- ,0x0203 : self._cb_handleVODPlayerStop
- ,0x0204 : self._cb_handleVODPlayerPlayPause
- ,0x0401 : self._cb_handleDVBAppVolUp
- ,0x0402 : self._cb_handleDVBAppVolDown
- ,0x0501 : self._cb_handleSystemOutOfMemory
- ,0x0502 : self._cb_handleSystemNotufyMyPID
- }
- self._on_close_cb = None
- self._on_set_title_cb = None
-
- self._vod_uri = None
-
- self._retry_open_url = None
- self._timer_retry_open = eTimer()
-
-
- def _handle_dump(self, handle, opcode, data=None):
- if True: return
- print str(handle)
- try:
- print " - opcode : ", self.opcode.what(opcode)
- except: pass
- print " - data : ", data
-
- def doHandle(self, data, onCloseCB, onSetPageTitleCB):
- opcode, params, reserved = None, None, 0
- self._on_close_cb = onCloseCB
- self._on_set_title_cb = onSetPageTitleCB
- try:
- datas = self.doUnpack(data)
- except Exception, ErrMsg:
- print "Unpacking packet ERR :", ErrMsg
- params = 'fail to unpack packet!!'
- opcode = self.opcode.get("OP_UNKNOWN")
- return self.doPack(opcode, params)
+ self.current_title = None
+ self.max_volume = -1
+ self.soft_volume = -1
+ self.videobackend_activate = False
+ self.onSetTitleCB = []
+ self.onCloseCB = []
+ VBHandlers.__init__(self, _OPCODE_LIST, '_CB_')
+
+ def set_volume(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:
- opcode = datas[0]
- params = datas[1]
- self.opcode.what(opcode)
+ VolumeControl.instance.volctrl.setVolume(self.max_volume, self.max_volume)
- try:
- #print self.handle_map[opcode]
- (reserved, params) = self.handle_map[opcode](opcode, params)
- except Exception, ErrMsg:
- print "Handling packet ERR :", ErrMsg
- params = 'fail to handle packet!!'
- opcode = self.opcode.get("OP_UNKNOWN")
- return self.doPack(opcode, params)
- self._on_close_cb = None
- self._on_set_title_cb = None
- return self.doPack(opcode, params, reserved)
-
- def _cb_handleHbbTVRetryOpen(self, opcode, data):
- def _cb_HbbTVRetryOpenURL():
- self._timer_retry_open.stop()
- if self._retry_open_url is not None:
- command_util = getCommandUtil()
- command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
- self._retry_open_url = None
- self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
- headLen = struct.calcsize('!I')
- unpackedData = struct.unpack('!I', data[:headLen])
- delayTime = unpackedData[0]
- restartUrl = data[headLen:]
-
- self._retry_open_url = restartUrl.strip()
- self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
- self._timer_retry_open.start(delayTime*1000)
- return (0, "OK")
-
- def _cb_handleSystemNotufyMyPID(self, opcode, data):
- self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
- return (0, "OK")
-
- def _cb_handleSystemOutOfMemory(self, opcode, data):
- self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
- setNeedRestart(True)
- return (0, "OK")
-
- def _cb_handleDVBAppVolUp(self, opcode, data):
- self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
- vcm = VolumeControl.instance
- vcm.volUp()
- return (0, "OK")
-
- def _cb_handleDVBAppVolDown(self, opcode, data):
- self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
- vcm = VolumeControl.instance
- vcm.volDown()
- return (0, "OK")
-
- def _cb_handleGetChannelInfoForUrl(self, opcode, data):
- self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
- (sid, onid, tsid, name, orgid) = getChannelInfos()
- namelen = len(name)
- return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
-
- def _cb_handleGetChannelInfoForAIT(self, opcode, data):
- self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
- (sid, onid, tsid, name, orgid) = getChannelInfos()
- namelen = len(name)
- return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
-
- def _cb_handleGetChannelInfoList(self, opcode, data):
- self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
- (sid, onid, tsid, name, orgid) = getChannelInfos()
- namelen = len(name)
- channel_list_size = 1
- 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)
- if data.startswith('file://') or data.startswith('http://'):
- return "OK"
- if self._on_set_title_cb is not None:
- for x in self._on_set_title_cb:
- try:
- x(data)
- except Exception, ErrMsg:
- if x in self._on_set_title_cb:
- self._on_set_title_cb.remove(x)
- return (0, "OK")
-
- def _cb_handleCloseHbbTVBrowser(self, opcode, data):
- self._timer_retry_open.stop()
- self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
-
- if self._on_close_cb:
- for x in self._on_close_cb:
+ def close_vkb(self, data=""):
+ fbClass.getInstance().lock()
+ eRCInput.getInstance().lock()
+
+ if strIsEmpty(data):
+ data = ""
+ VBController.command("BROWSER_VKB_CLOSE", data)
+
+ def _CB_CONTROL_EXIT(self, result, packet):
+ if self.onCloseCB:
+ for x in self.onCloseCB:
try:
x()
- except Exception, ErrMsg:
- if x in self._on_close_cb:
- self._on_close_cb.remove(x)
-
- 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
- return (0, "OK")
-
- def _cb_handleVODPlayerURI(self, opcode, data):
- self._vod_uri = None
- hl = struct.calcsize('!II')
- datas = struct.unpack('!II', data[:hl])
- uriLength = datas[1]
- vodUri = data[hl:hl+uriLength]
- self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
- self._vod_uri = vodUri
- return (0, "OK")
-
- def doStop(self, restoreBeforeService=True, needStop=True):
- if needStop == True:
- self._session.nav.stopService()
- if self._vod_service is not None and restoreBeforeService:
- before_service = getBeforeService()
- self._session.nav.playService(before_service)
- self._vod_uri = None
- self._vod_service = None
-
- def getUrl(self):
- return self._vod_uri
-
- def doRetryOpen(self, url):
- if url is None:
- return False
- for ii in range(5):
- self._vod_service = None
+ except Exception:
+ if x in self.onCloseCB:
+ self.onCloseCB.remove(x)
+ if self.videobackend_activate is False:
+ if vbcfg.g_service is not None:
+ self._session.nav.playService(vbcfg.g_service)
+ return (True, None)
+
+ def _CB_CONTROL_TITLE(self, result, packet):
+ if packet.startswith('file://') or packet.startswith('http://'):
+ return (True, None)
+ for x in self.onSetTitleCB:
try:
- print "Try to open vod [%d] : %s" % (ii, url)
- 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:
- print "OpenVOD ERR :", ErrMsg
- time.sleep(1)
- return False
-
- def _cb_handleVODPlayerPlay(self, opcode, data):
- self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
- self.doStop(restoreBeforeService=False)
- if self.doRetryOpen(url=self._vod_uri) == False:
- self.doStop()
- return (0, "OK")
-
- def _cb_handleVODPlayerStop(self, opcode, data):
- self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
- self.doStop()
- return (0, "OK")
-
- def _cb_handleVODPlayerPlayPause(self, opcode, data):
- self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
- service = self._session.nav.getCurrentService()
- try:
- pauseFlag = data[0]
- servicePause = service.pause()
- if pauseFlag == 'U':
- servicePause.unpause()
- elif pauseFlag == 'P':
- servicePause.pause()
- except Exception, ErrMsg:
- print "onPause ERR :", ErrMsg
- return (0, "OK")
-
-from libshm import SimpleSharedMemory
-_g_ssm_ = None
-class HbbTVWindow(Screen, InfoBarNotifications):
- skin = """
- <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
- </screen>
- """
- def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
- self._session = session
- eRCInput.getInstance().lock()
-
+ x(packet)
+ self.current_title = packet
+ except Exception:
+ if x in self.onSetTitleCB:
+ self.onSetTitleCB.remove(x)
+ return (True, None)
+
+ def _CB_CONTROL_OK(self, result, packet):
+ if vbcfg.g_browser and packet.startswith('stop'):
+ vbcfg.g_browser.keyOK()
+ return (True, None)
+
+ def _CB_CONTROL_OUT_OF_MEMORY(self, result, packet):
+ vbcfg.need_restart = True;
+ return (True, None)
+
+ def _CB_CONTROL_INVALIDATE(self, result, packet):
+ # redraw enigma
+ from enigma import getDesktop
+ getDesktop(0).paint()
+ return (True, None)
+
+ def _CB_CONTROL_GET_FBSIZE(self, result, packet):
+ from enigma import getDesktop
+ desktop_size = getDesktop(0).size()
+ data = "%dx%d" % (desktop_size.width(), desktop_size.height())
+ return (True, data)
+
+ def _CB_CONTROL_SET_VOLUME(self, result, packet):
+ if self.max_volume < 0:
+ self.max_volume = VolumeControl.instance.volctrl.getVolume()
+ self.soft_volume = int(packet)
+
+ 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 (True, None)
+
+ def _CB_CONTROL_VOLUME_UP(self, result, packet):
+ self.set_volume(5)
+ return (True, None)
+
+ def _CB_CONTROL_VOLUME_DOWN(self, result, packet):
+ self.set_volume(-5)
+ return (True, None)
+
+ def _CB_BROWSER_MENU_OPEN(self, result, packet):
+ if vbcfg.g_browser and vbcfg.g_browser.is_browser_opened:
+ vbcfg.setPosition(vbcfg.g_position)
+ fbClass.getInstance().unlock()
+ eRCInput.getInstance().unlock()
+
+ vbcfg.g_browser.toggle_browser(packet, self.current_title)
+ return (True, None)
+
+ def _CB_BROWSER_VKB_OPEN(self, result, packet):
+ if vbcfg.g_browser and vbcfg.g_browser.is_browser_opened:
+ vbcfg.setPosition(vbcfg.g_position)
+ fbClass.getInstance().unlock()
+ eRCInput.getInstance().unlock()
+
+ if strIsEmpty(packet):
+ packet = ""
+ self._session.openWithCallback(self.close_vkb, VirtualKeyBoard, title=("Please enter URL here"), text=str(packet))
+ return (True, None)
+
+ def _CB_OOIF_GET_CURRENT_CHANNEL(self, result, packet):
+ if (vbcfg.g_channel_info):
+ try:
+ data = struct.pack('iiii', vbcfg.g_channel_info[0], vbcfg.g_channel_info[1], vbcfg.g_channel_info[2], len(vbcfg.g_channel_info[3])) + vbcfg.g_channel_info[3]
+ except Exception, err:
+ vbcfg.ERR(err)
+ return (False, None)
+ else:
+ return (False, None)
+ return (True, data)
+
+ def _CB_OOIF_BROADCAST_PLAY(self, result, packet):
+ if vbcfg.g_service is not None:
+ self._session.nav.playService(vbcfg.g_service)
+ self.videobackend_activate = False
+ return (True, None)
+
+ def _CB_OOIF_BROADCAST_STOP(self, result, packet):
+ vbcfg.g_service = self._session.nav.getCurrentlyPlayingServiceReference()
+ self._session.nav.stopService()
+ self.videobackend_activate = True
+ return (True, None)
+
+ def _CB_OOIF_BROADCAST_CHECK(self, result, packet):
+ if self._session.nav.getCurrentService() is None:
+ return (False, None)
+ return (True, None)
+
+class VBMain(Screen):
+ skin = """<screen name="VBMAIN" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
+ def __init__(self, session):
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,
- })
-
- self._url = url
- self._use_ait = useAIT
- self._profile = profile
- self._cb_closed_func = cbf
- self.onLayoutFinish.append(self._layoutFinished)
-
- command_server = getCommandServer()
- if self._cb_set_page_title not in command_server.onSetPageTitleCB:
- command_server.onSetPageTitleCB.append(self._cb_set_page_title)
-
- if self._cb_close_window not in command_server.onHbbTVCloseCB:
- command_server.onHbbTVCloseCB.append(self._cb_close_window)
-
- self._closeTimer = eTimer()
- self._closeTimer.callback.append(self._do_close)
-
- self._currentServicePositionTimer = eTimer()
- self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
- self._vodLength = 0
-
- global _g_ssm_
- self._ssm = _g_ssm_
- self._vod_length = 0
-
- def getVodPlayTime(self):
- try:
- service = self._session.nav.getCurrentService()
- seek = service and service.seek()
- l = seek.getLength()
- p = seek.getPlayPosition()
- #return (p[1]/90000, l[1]/90000)
- return (p[1], l[1])
- except: pass
- return (-1,-1)
-
- def _cb_currentServicePosition(self):
- def getTimeString(t):
- t = time.localtime(t/90000)
- return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
- position,length = 0,0
- try:
- (position,length) = self.getVodPlayTime()
- self._vod_length = length
- if position == -1 and length == -1:
- raise Exception("Can't get play status")
- #print getTimeString(position), "/", getTimeString(length)
- self._ssm.setStatus(position, length, 1)
- except Exception, ErrMsg:
- print ErrMsg
- self._serviceEOF()
-
- def _serviceStarted(self):
- try:
- self._ssm.setStatus(0, 0, 0)
- self._currentServicePositionTimer.start(1000)
- except Exception, ErrMsg:
- print ErrMsg
-
- def _serviceEOF(self):
- self._currentServicePositionTimer.stop()
-
- def _layoutFinished(self):
- command_util = getCommandUtil()
- profile = self._profile
- (sid, onid, tsid, name, orgid) = getChannelInfos()
- 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)
- command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
- return
- command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
- time.sleep(1)
- command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
-
- def _cb_close_window(self):
- self._closeTimer.start(1000)
-
- def _do_close(self):
- self._closeTimer.stop()
- command_server = getCommandServer()
- try:
- if self._cb_set_page_title in command_server.onSetPageTitleCB:
- command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
- except Exception, ErrMsg: pass
- try:
- if self._cb_close_window in command_server.onHbbTVCloseCB:
- 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
- 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 = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
- def __init__(self, session):
- global __gval__
- __gval__.hbbtv_handelr = HandlerHbbTV(session)
- __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
+ self.vbcallback = None
+ self.vbhandler = VBHandler(session)
+ self.vbserver = VBServerThread()
+ self.vbserver.open(1)
+ self.vbserver.start()
- self._urls = None
- #self._stop_opera()
- #self._start_opera()
- self._restart_opera()
+ # comment for dev
+ self.restart_browser()
+ vbcfg.LOG("browser start")
- Screen.__init__(self, session)
- self._session = session
self._timer_infobar = eTimer()
- self._timer_infobar.callback.append(self._cb_registrate_infobar)
+ self._timer_infobar.callback.append(self._cb_register_infobar)
self._timer_infobar.start(1000)
- self._excuted_browser = False
- self._profile = 0
-
- __gval__.command_util = BrowserCommandUtil()
+ self._event = ServiceEventTracker(screen=self, eventmap={
+ iPlayableService.evHBBTVInfo: self._cb_ait_detected,
+ iPlayableService.evUpdatedInfo: self._cb_info_updated
+ })
+ self._applicationList = None
+ self._app_info = None
- global _g_ssm_
- if _g_ssm_ is None:
- _g_ssm_ = SimpleSharedMemory()
- _g_ssm_.doConnect()
+ try:
+ from Screens.InfoBarGenerics import gHbbtvApplication
+ self.m_vuplus = gHbbtvApplication.getUseAit()
+ except:
+ self.m_vuplus = False
- def _cb_registrate_infobar(self):
+ def _cb_register_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)
+ vbcfg.DEBUG("registred HbbTV in InfoBar")
- 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
- setChannelInfo(None, None, None, None, None)
-
- service = self._session.nav.getCurrentService()
- info = service and service.info()
- if info is not None:
- 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)
-
- 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."
+ def _cb_hbbtv_activated(self, url=None, app_info=None):
+ if not self.check_browser():
+ message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
return
- service = self._session.nav.getCurrentlyPlayingServiceReference()
- setBeforeService(service)
- self._start_hbbtv_application(title, url)
-
- def _start_hbbtv_application(self, title, url):
- use_ait = False
- tmp_url = self.getStartHbbTVUrl()
- if url is None:
- url = tmp_url
- if strIsEmpty(url):
- print "can't get url of hbbtv!!"
- return
- print "success to get url of hbbtv!! >>", url
- if self._excuted_browser:
- print "already excuted opera browser!!"
- return
+ self.start_hbbtv_application(url, app_info)
+
+ def _cb_ait_detected(self):
+ vbcfg.g_channel_info = None
+ self._applicationList = None
+ self._app_info = self.get_autostart_application()
+ vbcfg.DEBUG("detected AIT")
+
+ def _cb_info_updated(self):
+ vbcfg.g_service = self.session.nav.getCurrentlyPlayingServiceReference()
+ vbcfg.DEBUG("updated channel info")
+
+ def start_hbbtv_application(self, url, app_info):
+ if vbcfg.need_restart:
+ self.restart_browser()
+ os.time.sleep(2)
+ vbcfg.need_restart = False
+
+ if not app_info:
+ app_info = self._app_info
+ self.session.open(HbbTVWindow, url, app_info)
+
+ def menu_toggle_browser(self, callback=None):
+ mode = []
+ self.vbcallback = callback
+ if self.check_browser():
+ mode.append((_('Stop'), 'Stop'))
+ else:
+ mode.append((_('Start'), 'Start'))
+ self.session.openWithCallback(self.toggle_browser, ChoiceBox, title=_("Please choose one."), list=mode)
- if isNeedRestart():
- self._restart_opera()
- time.sleep(2)
- setNeedRestart(False)
-
- for x in self._urls:
- control_code = x[0]
- tmp_url = x[2]
- if tmp_url == url and control_code == 1:
- use_ait = True
- self._excuted_browser = True
- self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
-
- def _cb_closed_browser(self):
- self._excuted_browser = False
-
- def _start_opera(self):
- if not self._is_browser_running():
- global HBBTVAPP_PATH
- start_command = '%s/launcher start'%(HBBTVAPP_PATH)
- os.system(start_command)
-
- def _stop_opera(self):
- global HBBTVAPP_PATH
- try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
- except: pass
+ def toggle_browser(self, selected):
+ if selected is not None:
+ if self.vbcallback:
+ self.vbcallback()
+ try:
+ mode = selected[1]
+ if mode == 'Start':
+ if not self.check_browser():
+ self.start_browser()
+ elif mode == 'Stop':
+ self.stop_browser()
- def _restart_opera(self):
- global HBBTVAPP_PATH
- try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
- except: pass
+ except Exception, ErrMsg:
+ vbcfg.ERR("toggle browser: %s" % ErrMsg)
- 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]
- if url is None:
- url = info.getInfoString(iServiceInformation.sHBBTVUrl)
- return url
-
- def showApplicationSelectionBox(self):
+ def menu_hbbtv_applications(self):
applications = []
+ if self._applicationList is not None:
+ for x in self._applicationList:
+ applications.append((x["name"], x))
+ else:
+ applications.append((_("No detected HbbTV applications."), None))
+ self.session.openWithCallback(self.start_application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
- if self.getStartHbbTVUrl():
- for x in self._urls:
- applications.append((x[1], 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):
- try:
- if selected[1] is None: return
- self._cb_hbbtv_activated(selected[1][1], selected[1][2])
- except Exception, ErrMsg: print ErrMsg
-
- def showBrowserConfigBox(self):
- start_stop_mode = []
- if self._is_browser_running():
- start_stop_mode.append(('Stop',None))
- else: start_stop_mode.append(('Start',None))
- self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
-
- def _browser_config_selected(self, selected):
- if selected is None:
- return
+ def start_application_selected(self, selected):
+ vbcfg.DEBUG(selected)
try:
- mode = selected[0]
- if mode == 'Start':
- if not self._is_browser_running():
- self._start_opera()
- elif mode == 'Stop':
- self._stop_opera()
- except Exception, ErrMsg: print "Config ERR :", ErrMsg
-
- def _is_browser_running(self):
- try:
- global HBBTVAPP_PATH
- ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
- return ret.strip() != "0"
+ if selected[1] is not None:
+ self._cb_hbbtv_activated(selected[1]["url"], selected[1])
except Exception, ErrMsg:
- print "Check Browser Running ERR :", ErrMsg
- return False
+ vbcfg.ERR(ErrMsg)
+
+ def get_autostart_application(self):
+ if self._applicationList is None:
+ service = self.session.nav.getCurrentService()
+ info = service and service.info()
+ if info is not None:
+ sid = info.getInfo(iServiceInformation.sSID)
+ onid = info.getInfo(iServiceInformation.sONID)
+ tsid = info.getInfo(iServiceInformation.sTSID)
+ name = info.getName()
+ vbcfg.g_channel_info = (sid, onid, tsid, name)
+
+ pmtid = info.getInfo(iServiceInformation.sPMTPID)
+ demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
+ vbcfg.DEBUG("demux = %s, pmtid = 0x%x, sid = 0x%x" % (demux, pmtid, sid))
+
+ from aitreader import eAITSectionReader
+ reader = eAITSectionReader(demux, pmtid, sid)
+ if reader.doOpen(info, self.m_vuplus):
+ reader.doParseApplications()
+ reader.doDump()
+ else:
+ vbcfg.ERR("no AIT")
-_g_helper = None
-class OperaBrowser(Screen):
- MENUBAR_ITEM_WIDTH = 150
- MENUBAR_ITEM_HEIGHT = 30
- SUBMENULIST_WIDTH = 200
- SUBMENULIST_HEIGHT = 25
- SUBMENULIST_NEXT = 2
-
- skin = """
- <screen name="Opera Browser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
- <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
- <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
- <widget name="menuitemHelp" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
- <widget name="menulist" position="50,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
- <widget name="submenulist" position="%d,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
- <widget name="bottomArea" position="0,640" size="1280,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
- </screen>
- """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)
-
- MENUITEMS_LIST =[[('Open Location', None), ('Start/Stop',None), ('Exit', None)],
- [('About', None)]]
- def __init__(self, session):
- Screen.__init__(self, session)
+ try:
+ self._applicationList = reader.getApplicationList()
+ except:
+ pass
+
+ if self._applicationList is not None:
+ for app in self._applicationList:
+ if app["control"] in (1, -1):
+ return app
+ return None
- self["actions"] = ActionMap(["MinuteInputActions", "ColorActions", "InputActions", "InfobarChannelSelection", "EPGSelectActions", "KeyboardInputActions"], {
- "cancel" : self.keyCancel
- ,"ok" : self.keyOK
- ,"left" : self.keyLeft
- ,"right" : self.keyRight
- ,"up" : self.keyUp
- ,"down" : self.keyDown
- ,"menu" : self.keyCancel
- }, -2)
+ def start_browser(self):
+ if not self.check_browser():
+ os.system("%s/%s start"%(vbcfg.APPROOT, vbcfg.APP_RUN))
+ return True
- self.menubarCurrentIndex = 0
- self.lvMenuItems = []
- self.lvSubMenuItems = []
-
- self["topArea"] = Label()
- self["bottomArea"] = Label()
-
- self["menuitemFile"] = MultiColorLabel()
- self["menuitemHelp"] = MultiColorLabel()
-
- self["menulist"] = MenuList(self.setListOnView())
- self["submenulist"] = MenuList(self.setSubListOnView())
-
- self.toggleMainScreenFlag = True
- self.toggleListViewFlag = False
- self.toggleSubListViewFlag = False
- self.currentListView = self["menulist"]
-
- self.onLayoutFinish.append(self.layoutFinished)
-
- self._onCloseTimer = eTimer()
- self._onCloseTimer.callback.append(self._cb_onClose)
-
- def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
- rcmouse_path = "/proc/stb/fp/mouse"
- if os.path.exists(rcmouse_path):
- os.system("echo %d > %s" % (mode, rcmouse_path))
-
- def layoutFinished(self):
- self["menuitemFile"].setText("File")
- self["menuitemHelp"].setText("Help")
-
- self["menulist"].hide()
- self["submenulist"].hide()
-
- self["bottomArea"].setText("Opera Web Browser Plugin v0.1")
- self.setTitle("BrowserMain")
- self.selectMenuitem()
-
- def selectMenuitem(self):
- tmp = [self["menuitemFile"], self["menuitemHelp"]]
- self["menuitemFile"].setForegroundColorNum(0)
- self["menuitemHelp"].setForegroundColorNum(0)
- tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
-
- def popupCloseAll(self):
- self.keyLeft()
- self.keyLeft()
- self.keyUp()
- self.keyCancel()
-
- def setListOnView(self):
- self.lvMenuItems = self.MENUITEMS_LIST[self.menubarCurrentIndex]
- return self.lvMenuItems
-
- def setSubListOnView(self):
- self.lvSubMenuItems = []
- xl = self["menulist"].getCurrent()[1]
- if xl is None: return []
- for x in xl:
- self.lvSubMenuItems.append((x,None))
- return self.lvSubMenuItems
-
- def toggleMainScreen(self):
- if not self.toggleMainScreenFlag:
- self.show()
- else: self.hide()
- self.toggleMainScreenFlag = not self.toggleMainScreenFlag
-
- def toggleListView(self):
- if not self.toggleListViewFlag:
- self["menulist"].show()
- else: self["menulist"].hide()
- self.toggleListViewFlag = not self.toggleListViewFlag
-
- def toggleSubListView(self):
- if not self.toggleSubListViewFlag:
- self["submenulist"].show()
- else: self["submenulist"].hide()
- self.toggleSubListViewFlag = not self.toggleSubListViewFlag
-
- def setCurrentListView(self, listViewIdx):
- if listViewIdx == 0:
- self.currentListView = None
- elif listViewIdx == 1:
- self.currentListView = self["menulist"]
- elif listViewIdx == 2:
- self.currentListView = self["submenulist"]
-
- def _cb_onClose(self):
- self._onCloseTimer.stop()
- command_server = getCommandServer()
- try:
- if self._on_close_window in command_server.onHbbTVCloseCB:
- command_server.onHbbTVCloseCB.remove(self._on_close_window)
- except Exception, ErrMsg: pass
+ def stop_browser(self):
+ VBController.command('CONTROL_EXIT')
+ return True
try:
- if self._on_setPageTitle in command_server.onSetPageTitleCB:
- command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
- except Exception, ErrMsg: pass
- self._on_setPageTitle('Opera Browser')
- self.enableRCMouse(False)
- self.toggleMainScreen()
- eRCInput.getInstance().unlock()
-
- def _on_setPageTitle(self, title=None):
- print "Title :",title
- if title is None:
- return
- self.setTitle(title)
-
- def cbUrlText(self, data=None):
- print "Inputed Url :", data
- if strIsEmpty(data):
- return
- command_server = getCommandServer()
- if self._on_setPageTitle not in command_server.onSetPageTitleCB:
- 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)
- eRCInput.getInstance().lock()
- command_util = getCommandUtil()
- command_util.sendCommand('OP_BROWSER_OPEN_URL', data)
+ os.system("%s/%s stop"%(vbcfg.APPROOT, vbcfg.APP_RUN))
+ except:
+ pass
+ return True
- def _on_close_window(self):
- self._onCloseTimer.start(1000)
+ def check_browser(self):
+ try:
+ ret = os.popen('%s/%s check'%(vbcfg.APPROOT, vbcfg.APP_RUN)).read()
+ return ret.strip() != "0"
+ except Exception, ErrMsg:
+ vbcfg.ERR("check browser running: %s" % ErrMsg)
+ return False
- def _cmd_on_OpenLocation(self):
- 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.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=("Please enter URL here"), text='http://')
- def _cmd_on_About(self):
- self.session.open(MessageBox, 'Opera Web Browser Plugin v0.1(beta)', type = MessageBox.TYPE_INFO)
- def _cmd_on_Exit(self):
- self.close()
- def _cmd_on_StartStop(self):
- global _g_helper
- if _g_helper is None:
- return
- _g_helper.showBrowserConfigBox()
- def doCommand(self, command):
- cmd_map = {
- 'Exit' :self._cmd_on_Exit
- ,'About' :self._cmd_on_About
- ,'Open Location' :self._cmd_on_OpenLocation
- ,'Start/Stop' :self._cmd_on_StartStop
- }
+ def restart_browser(self):
try:
- cmd_map[command]()
- except: pass
+ os.system("%s/%s restart"%(vbcfg.APPROOT, vbcfg.APP_RUN))
+ except:
+ pass
+ return True
- def keyOK(self):
- if not self.toggleListViewFlag:
- self.keyDown()
- return
- if self.currentListView.getCurrent()[1] is None:
- self.doCommand(self.currentListView.getCurrent()[0])
- #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
- return
- self.keyRight()
-
- def updateSelectedMenuitem(self, status):
- if self.menubarCurrentIndex == 0 and status < 0:
- self.menubarCurrentIndex = 1
- elif self.menubarCurrentIndex == 1 and status > 0:
- self.menubarCurrentIndex = 0
- else: self.menubarCurrentIndex += status
- self.selectMenuitem()
-
- def keyLeft(self):
- if not self.toggleMainScreenFlag:
- return
- if not self.toggleListViewFlag:
- self.updateSelectedMenuitem(-1)
- return
- if self.toggleSubListViewFlag:
- self.setCurrentListView(1)
- self.toggleSubListView()
- return
- if self.currentListView.getSelectedIndex():
- self.currentListView.pageUp()
+def HelpableScreen__init__(self):
+ if isinstance(self, HelpableScreen):
+ HelpableScreen.showManual = showManual
- def keyRight(self):
- if not self.toggleMainScreenFlag:
- return
- if not self.toggleListViewFlag:
- self.updateSelectedMenuitem(1)
- return
- if self.currentListView is None:
- return
- if self.currentListView.getCurrent()[1] is not None:
- parentSelectedIndex = self.currentListView.getSelectedIndex()
- self.setCurrentListView(2)
- self.currentListView.setList(self.setSubListOnView())
- self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
- self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex + self.SUBMENULIST_WIDTH+self.SUBMENULIST_NEXT + 50,self.MENUBAR_ITEM_HEIGHT+30+(parentSelectedIndex*self.SUBMENULIST_HEIGHT))
- self.toggleSubListView()
-
- def keyDown(self):
- if not self.toggleMainScreenFlag:
- return
- if self.currentListView is None:
- return
- if not self.toggleListViewFlag:
- self.currentListView.setList(self.setListOnView())
- self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
- self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
- self.toggleListView()
- return
- self.currentListView.down()
+ self["helpActions"] = ActionMap(["HelpbuttonActions"], {
+ "help_b" : self.showHelp,
+ "help_l" : self.showManual,
+ }, -2)
- def keyUp(self):
- if not self.toggleMainScreenFlag:
- return
- if self.currentListView is None:
- return
- if self.currentListView == self["menulist"]:
- if self.currentListView.getSelectedIndex() == 0:
- self.toggleListView()
- return
- self.currentListView.up()
+def showManual(self):
+ if not os.path.exists(vbcfg.MANUALROOT):
+ return
- def keyCancel(self):
- self.toggleMainScreen()
+ url = 'file://' + vbcfg.MANUALROOT + '/main.html'
+ lang = language.getLanguage()
+ if os.path.exists(vbcfg.MANUALROOT + '/' + lang):
+ url = 'file://' + vbcfg.MANUALROOT + '/' + lang + '/main.html'
+
+ vbcfg.g_browser = self.session.open(Browser, url)
def auto_start_main(reason, **kwargs):
if reason:
- command_server = getCommandServer()
- command_server.stop()
+ try:
+ if vbcfg.g_main.vbserver is not None:
+ vbcfg.g_main.vbserver.kill()
+ except: pass
def session_start_main(session, reason, **kwargs):
- eRCInput.getInstance().unlock()
- global _g_helper
- _g_helper = session.open(HbbTVHelper)
-
-def plugin_start_main(session, **kwargs):
- session.open(OperaBrowser)
-
-def plugin_extension_start_application(session, **kwargs):
- global _g_helper
- if _g_helper is None:
- return
- _g_helper.showApplicationSelectionBox()
-
-def plugin_extension_browser_config(session, **kwargs):
- global _g_helper
- if _g_helper is None:
- return
- _g_helper.showBrowserConfigBox()
-
-def Plugins(path, **kwargs):
- return [
- PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main),
- PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10),
- PluginDescriptor(name="HbbTV Applications", where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application),
- PluginDescriptor(name="Browser Start/Stop", where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config),
- PluginDescriptor(name="Opera Web Browser", description="start opera web browser", where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main),
- ]
-
+ vbcfg.g_main = session.open(VBMain)
+ HelpableScreen.__init__ = HelpableScreen__init__
+ HelpableScreen.session = session
+
+def start_youtubetv_main(session, **kwargs):
+ def _cb_youtubetv_close(ret):
+ if ret:
+ vbcfg.g_service = session.nav.getCurrentlyPlayingServiceReference()
+ if vbcfg.g_service is not None:
+ session.nav.stopService()
+ vbcfg.g_browser = session.open(Browser, vbcfg.g_youtubetv_cfg.uri.value, True)
+
+ if config.plugins.youtubetv.showhelp.value == True:
+ _cb_youtubetv_close(True)
+ else:
+ session.openWithCallback(_cb_youtubetv_close, YoutubeTVWindow)
+
+
+def menu_start_youtube(menuid, **kwargs):
+ if menuid == "mainmenu":
+ return [(_("YouTube TV"), start_youtubetv_main, "youtube_tv", 46)]
+ return []
+
+def plugin_setting_youtube(session, **kwargs):
+ session.open(YoutubeTVSettings)
+
+def plugin_start_browser(session, **kwargs):
+ vbcfg.g_browser = session.open(Browser)
+
+def extension_toggle_browser(session, **kwargs):
+ if vbcfg.g_main is not None:
+ vbcfg.g_main.menu_toggle_browser()
+
+def extension_start_application(session, **kwargs):
+ if vbcfg.g_main is not None:
+ vbcfg.g_main.menu_hbbtv_applications()
+
+def Plugins(**kwargs):
+ l = []
+ l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
+ l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
+ l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=menu_start_youtube))
+ l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=plugin_setting_youtube))
+ l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=extension_toggle_browser))
+ l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=extension_start_application))
+ l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_browser))
+ return l