from Plugins.Plugin import PluginDescriptor
from Screens.Screen import Screen
from Screens.InfoBar import InfoBar
from Screens.ChoiceBox import ChoiceBox
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.ServiceEventTracker import ServiceEventTracker
from Components.MenuList import MenuList
from Components.Label import Label, MultiColorLabel
from Components.ConfigList import ConfigListScreen
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)
__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 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 "Send Data : "
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_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_BROWSER_OPEN_URL" : 0x0301
}
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"
,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"
,0x0301 : "OP_BROWSER_OPEN_URL"
}
def get(self, opstr):
try:
return self._opcode_[opstr]
except: pass
return self._opcode_["OP_UNKNOWN"]
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
while not self._terminated:
readable, writable, errored = select.select(select_list, [], [], self._timeout)
for s in readable:
if s is self._socket:
_accept()
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
print "connected!! to ", filename
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 "connected 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
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
class HandlerHbbTV(Handler):
_vod_service = None
def __init__(self, session):
self._session = session
self.opcode = OpCodeSet()
self.handle_map = {
0x0001 : self._cb_handleCloseHbbTVBrowser
,0x0006 : self._cb_handleSetPageTitle
,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
}
self._on_close_cb = None
self._on_set_title_cb = None
self._vod_uri = None
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)
else:
opcode = datas[0]
params = datas[1]
self.opcode.what(opcode)
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_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._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
if self._on_close_cb:
for x in self._on_close_cb:
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)
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
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")
class HbbTVWindow(Screen, InfoBarNotifications):
skin = """
"""
def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
self._session = session
eRCInput.getInstance().lock()
Screen.__init__(self, session)
InfoBarNotifications.__init__(self)
self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
iPlayableService.evUser+20: self._serviceForbiden,
})
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)
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 = """"""
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()
Screen.__init__(self, session)
self._session = session
self._timer_infobar = eTimer()
self._timer_infobar.callback.append(self._cb_registrate_infobar)
self._timer_infobar.start(1000)
self._excuted_browser = False
self._profile = 0
__gval__.command_util = BrowserCommandUtil()
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
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."
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):
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
use_ait = 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 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):
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
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"
except Exception, ErrMsg:
print "Check Browser Running ERR :", ErrMsg
return False
_g_helper = None
class OperaBrowser(Screen):
MENUBAR_ITEM_WIDTH = 150
MENUBAR_ITEM_HEIGHT = 30
SUBMENULIST_WIDTH = 200
SUBMENULIST_HEIGHT = 25
SUBMENULIST_NEXT = 2
skin = """
""" % (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)
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)
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
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 "page 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)
def _on_close_window(self):
self._onCloseTimer.start(1000)
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
}
try:
cmd_map[command]()
except: pass
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 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()
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 keyCancel(self):
self.toggleMainScreen()
def auto_start_main(reason, **kwargs):
if reason:
command_server = getCommandServer()
command_server.stop()
def session_start_main(session, reason, **kwargs):
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)
]