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
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
return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
def setChannelInfo(sid, onid, tsid, name, orgid):
- if sid is None: sid = 0;
- if onid is None: onid = 0;
- if tsid is None: tsid = 0;
- if name is None: name = "";
- if orgid is None: orgid = 0;
+ if sid is None: sid = 0
+ if onid is None: onid = 0
+ if tsid is None: tsid = 0
+ if name is None: name = ""
+ if orgid is None: orgid = 0
global __gval__
__gval__.channel_info_sid = sid
__gval__.channel_info_onid = onid
print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
def getChannelInfos():
global __gval__
- print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
+ print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
__gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
- return (__gval__.channel_info_sid,
- __gval__.channel_info_onid,
- __gval__.channel_info_tsid,
- __gval__.channel_info_name,
+ return (__gval__.channel_info_sid,
+ __gval__.channel_info_onid,
+ __gval__.channel_info_tsid,
+ __gval__.channel_info_name,
__gval__.channel_info_orgid)
def isNeedRestart():
packed_data = struct.pack(h, m, opcode, len(params), reserved)
return packed_data + params
-class MMSStreamURL:
- headers = [
- 'GET %s HTTP/1.0'
- ,'Accept: */* '
- ,'User-Agent: NSPlayer/7.10.0.3059 '
- ,'Host: %s '
- ,'Connection: Close '
- ]
-
- def __init__(self):
- self.sendmsg = ''
- for m in self.headers:
- self.sendmsg += m + '\n'
- self.sendmsg += '\n\n'
-
- def request(self, host, port=80, location='/'):
- sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
- sock.connect((host, port))
- sock.send(self.sendmsg%(location, host))
- print "Request."
- print self.sendmsg%(location, host)
- fullydata = ''
- while 1:
- res = sock.recv(1024)
- if res == '': break
- fullydata += res
- sock.close()
- return fullydata
-
- def parse(self, data):
- for d in data.splitlines():
- if d.startswith('Location: '):
- return d[9:]
- return None
-
- def getLocationData(self, url):
- url_list,host,location = None,None,None
- try:
- url = url[url.find(':')+3:]
- url_list = url.split('/')
- host = url_list[0]
- location = url[len(url_list[0]):]
- except Exception, err_msg:
- print err_msg
- return None
- html = self.request(host=host, location=location)
- return self.parse(html)
-
class OpCodeSet:
def __init__(self):
self._opcode_ = {
- "OP_UNKNOWN" : 0x0000
- ,"OP_HBBTV_EXIT" : 0x0001
- ,"OP_HBBTV_OPEN_URL" : 0x0002
- ,"OP_HBBTV_LOAD_AIT" : 0x0003
- ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
- ,"OP_HBBTV_FULLSCREEN" : 0x0005
- ,"OP_HBBTV_TITLE" : 0x0006
- ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
- ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
- ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
- ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
- ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
- ,"OP_VOD_URI" : 0x0201
- ,"OP_VOD_PLAY" : 0x0202
- ,"OP_VOD_STOP" : 0x0203
- ,"OP_VOD_PAUSE" : 0x0204
- ,"OP_VOD_STATUS" : 0x0205
- ,"OP_VOD_FORBIDDEN" : 0x0206
- ,"OP_VOD_STOPED" : 0x0207
- ,"OP_VOD_SPEED_CTRL" : 0x0208
- ,"OP_VOD_SEEK_CTRL" : 0x0209
- ,"OP_BROWSER_OPEN_URL" : 0x0301
- ,"OP_BROWSER_VKBD_REQ" : 0x0309
- ,"OP_BROWSER_VKBD_RES" : 0x030A
- ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
- ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
- ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
- ,"OP_BROWSER_MENU_REQ" : 0x030E
- ,"OP_BROWSER_MENU_RES" : 0x030F
- ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
- ,"OP_DVBAPP_VOL_UP" : 0x0401
- ,"OP_DVBAPP_VOL_DOWN" : 0x0402
- ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
- ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
+ "OP_UNKNOWN" : 0x0000
+ ,"OP_HBBTV_EXIT" : 0x0001
+ ,"OP_HBBTV_OPEN_URL" : 0x0002
+ ,"OP_HBBTV_LOAD_AIT" : 0x0003
+ ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
+ ,"OP_HBBTV_FULLSCREEN" : 0x0005
+ ,"OP_HBBTV_TITLE" : 0x0006
+ ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
+ ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
+ ,"OP_HBBTV_ABORT_SIG" : 0x000B
+ ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
+ ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
+ ,"OP_OIPF_GET_CHANNEL_INFO_LIST" : 0x0103
+ ,"OP_VOD_URI" : 0x0201
+ ,"OP_VOD_PLAY" : 0x0202
+ ,"OP_VOD_STOP" : 0x0203
+ ,"OP_VOD_PAUSE" : 0x0204
+ ,"OP_VOD_STATUS" : 0x0205
+ ,"OP_VOD_FORBIDDEN" : 0x0206
+ ,"OP_VOD_STOPED" : 0x0207
+ ,"OP_VOD_SPEED_CTRL" : 0x0208
+ ,"OP_VOD_SEEK_CTRL" : 0x0209
+ ,"OP_BROWSER_OPEN_URL" : 0x0301
+ ,"OP_BROWSER_VKBD_REQ" : 0x0309
+ ,"OP_BROWSER_VKBD_RES" : 0x030A
+ ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
+ ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
+ ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
+ ,"OP_BROWSER_MENU_REQ" : 0x030E
+ ,"OP_BROWSER_MENU_RES" : 0x030F
+ ,"OP_BROWSER_NEED_RELOAD_KEYMAP" : 0x0313
+ ,"OP_DVBAPP_VOL_UP" : 0x0401
+ ,"OP_DVBAPP_VOL_DOWN" : 0x0402
+ ,"OP_DVBAPP_SET_VOL" : 0x0403
+ ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
+ ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
+ ,"OP_VIDEOBACKEND_ENABLE" : 0x0601
+ ,"OP_VIDEOBACKEND_DISABLE" : 0x0602
+ ,"OP_BROWSER_OPEN_YOUTUBETV" : 0x0603
}
self._opstr_ = {
0x0000 : "OP_UNKNOWN"
,0x0006 : "OP_HBBTV_TITLE"
,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
+ ,0x000B : "OP_HBBTV_ABORT_SIG"
,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
,0x0205 : "OP_VOD_STATUS"
,0x0206 : "OP_VOD_FORBIDDEN"
,0x0207 : "OP_VOD_STOPED"
- ,0x0208 : "OP_VOD_SPEED_CTRL"
- ,0x0209 : "OP_VOD_SEEK_CTRL"
+ ,0x0208 : "OP_VOD_SPEED_CTRL"
+ ,0x0209 : "OP_VOD_SEEK_CTRL"
,0x0301 : "OP_BROWSER_OPEN_URL"
- ,0x0309 : "OP_BROWSER_VKBD_REQ"
+ ,0x0309 : "OP_BROWSER_VKBD_REQ"
,0x030A : "OP_BROWSER_VKBD_RES"
,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
,0x0401 : "OP_DVBAPP_VOL_UP"
,0x0402 : "OP_DVBAPP_VOL_DOWN"
- ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
+ ,0x0403 : "OP_DVBAPP_SET_VOL"
+ ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
+ ,0x0601 : "OP_VIDEOBACKEND_ENABLE"
+ ,0x0602 : "OP_VIDEOBACKEND_DISABLE"
+ ,0x0603 : "OP_BROWSER_OPEN_YOUTUBETV"
}
def get(self, opstr):
class SocketParams:
def __init__(self):
self.protocol = None
- self.type = None
- self.addr = None
+ self.type = None
+ self.addr = None
self.buf_size = 4096
- self.handler = None
- self.timeout = 5
- self.destroy = None
+ self.handler = None
+ self.timeout = 5
+ self.destroy = None
class StreamServer:
def __init__(self, params):
self._protocol = params.protocol
- self._type = params.type
- self._addr = params.addr
+ self._type = params.type
+ self._addr = params.addr
self._buf_size = params.buf_size
- self._handler = params.handler
- self._timeout = params.timeout
- self._destroy = params.destroy
+ self._handler = params.handler
+ self._timeout = params.timeout
+ self._destroy = params.destroy
self._terminated = False
self._server_thread = None
def _client(self, conn, addr):
try:
- send_data = ''
+ send_data = ''
received_data = conn.recv(self._buf_size)
if self._handler is not None and not strIsEmpty(received_data):
send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
self._send(conn, send_data)
- except Exception, ErrMsg:
+ except Exception, ErrMsg:
try: conn.close()
except:pass
if self._handler is not None:
class ServerFactory:
def doListenUnixTCP(self, name, handler):
def destroy(name):
- import os
try:
if os.path.exists(name):
os.unlink(name)
params = SocketParams()
params.protocol = socket.AF_UNIX
- params.type = socket.SOCK_STREAM
- params.addr = name
- params.handler = handler
- params.destroy = destroy
+ params.type = socket.SOCK_STREAM
+ params.addr = name
+ params.handler = handler
+ params.destroy = destroy
streamServer = StreamServer(params)
streamServer.start()
return False
os.write(self._fd, data)
print "Send OK!! :", command
- except: return False
+ except: return False
return True
def sendCommand(self, command, params=None, reserved=0):
,0x0006 : self._cb_handleSetPageTitle
,0x0009 : self._cb_handleHbbTVRetryOpen
,0x000A : self._cb_handleHbbTVChangeChannel
+ ,0x000B : self._cb_handleHbbTVAbortSig
,0x0101 : self._cb_handleGetChannelInfoForUrl
,0x0102 : self._cb_handleGetChannelInfoForAIT
,0x0103 : self._cb_handleGetChannelInfoList
,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
,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
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
self._on_set_title_cb = None
return self.doPack(opcode, params, reserved)
+ def _cb_handleVideobackendEnable(self, opcode, data):
+ self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
+ service = self._session.nav.getCurrentlyPlayingServiceReference()
+ setBeforeService(service)
+ self._session.nav.stopService()
+ return (0, "OK")
+
+ def _cb_handleVideobackendDisable(self, opcode, data):
+ self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
+ before_service = getBeforeService()
+ if before_service is not None:
+ self._session.nav.playService(before_service)
+ return (0, "OK")
+
def _cb_handleHbbTVChangeChannel(self, opcode, data):
self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
global _g_helper
- if _g_helper is None:
+ if _g_helper is None:
return (0, "NOK")
dataItems = data.split(":")
- sid = dataItems[0]
+ sid = dataItems[0]
tsid = dataItems[1]
if not _g_helper.doChangeChannel(sid, tsid):
return (0, "NOK")
def _cb_handleBrowserMenuReq(self, opcode, data):
self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
+ #restoreResolution()
fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
browser = getPluginBrowser()
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):
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):
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:
self._on_set_title_cb.remove(x)
return (0, "OK")
+ def _cb_handleHbbTVAbortSig(self, opcode, data):
+ self._cb_handleCloseHbbTVBrowser(opcode, data)
+ global __gval__
+ return (0, struct.pack('!II', __gval__.resX, __gval__.resY));
+
def _cb_handleCloseHbbTVBrowser(self, opcode, data):
self._timer_retry_open.stop()
try:
command_util = getCommandUtil()
command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
-
before_service = getBeforeService()
if before_service is not None:
self._session.nav.playService(before_service)
self._vod_uri = None
+
+ #restoreResolution()
return (0, "OK")
def _cb_handleVODPlayerURI(self, opcode, data):
for ii in range(5):
self._vod_service = None
try:
- print "Try to open vod [%d] : %s" % (ii, url)
+ #print "Try to open vod [%d] : %s" % (ii, url)
+ print "Try to open vod"
self._vod_service = eServiceReference(4097, 0, url)
self._session.nav.playService(self._vod_service)
if self._vod_service is not None:
return True
- except Exception, ErrMsg:
+ except Exception, ErrMsg:
print "OpenVOD ERR :", ErrMsg
time.sleep(1)
return False
def _cb_handleVODPlayerStop(self, opcode, data):
self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
- self.doStop()
+ self.doStop()
return (0, "OK")
def _cb_handleVODPlayerPlayPause(self, opcode, data):
from libshm import SimpleSharedMemory
_g_ssm_ = None
class HbbTVWindow(Screen, InfoBarNotifications):
- skin = """
+ 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
+ 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,
})
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)
self._vod_length = length
if position == -1 and length == -1:
raise Exception("Can't get play status")
- #print getTimeString(position), "/", getTimeString(length)
+ #print position, "/", length, " - ", getTimeString(position), "/", getTimeString(length)
self._ssm.setStatus(position, length, 1)
except Exception, ErrMsg:
print ErrMsg
self._currentServicePositionTimer.stop()
def _layoutFinished(self):
+ global __gval__
+ __gval__.hbbtv_handelr._soft_volume = -1
self.setTitle(_('HbbTV Plugin'))
command_util = getCommandUtil()
profile = self._profile
(sid, onid, tsid, name, orgid) = getChannelInfos()
- params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
+ params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
if self._use_ait:
command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
time.sleep(1)
except Exception, ErrMsg: pass
try:
if self._cb_close_window in command_server.onHbbTVCloseCB:
- command_server.onHbbTVCloseCB.remove(self._cb_close_window)
+ command_server.onHbbTVCloseCB.remove(self._cb_close_window)
except Exception, ErrMsg: pass
try:
if self._cb_closed_func is not None:
self._cb_closed_func()
except: pass
+ restoreResolution()
fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
self.close()
- def _serviceForbiden(self):
- global __gval__
- real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
- print "Received URI :\n", real_url
-
- if real_url is not None:
- __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
-
def _cb_set_page_title(self, title=None):
print "page title :",title
if title is None:
return
self.setTitle(title)
-class HbbTVHelper(Screen):
- skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
+class HbbTVHelper(Screen, InfoBarNotifications):
+ 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._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)
_g_ssm_ = SimpleSharedMemory()
_g_ssm_.doConnect()
+ self._callbackStartStop = None
+
+ self.__et = ServiceEventTracker(screen=self, eventmap={
+ iPlayableService.evHBBTVInfo: self._cb_detectedAIT,
+ iPlayableService.evUpdatedInfo: self._cb_updateInfo
+ })
+ self._applicationList = None
+
+ self.mVuplusBox = False
+ issue = open("/etc/issue").read()
+ if(issue.startswith("Vuplus")):
+ self.mVuplusBox = True
+
+ def _cb_detectedAIT(self):
+ name = self._cb_ready_for_ait()
+ if name is not None and self.mVuplusBox:
+ from Screens.InfoBarGenerics import gHbbtvApplication
+ gHbbtvApplication.setApplicationName(str(name))
+
+ def _cb_updateInfo(self):
+ if not self._excuted_browser:
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
+ if self.mVuplusBox:
+ from Screens.InfoBarGenerics import gHbbtvApplication
+ gHbbtvApplication.setApplicationName("")
+ #self._applicationList = None
+
def _cb_registrate_infobar(self):
if InfoBar.instance:
self._timer_infobar.stop()
- if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
- InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
- def _cb_ready_for_ait(self, orgId=0):
- if orgId == 0:
- if not self._excuted_browser:
- command_util = getCommandUtil()
- command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
- return
+ def _cb_ready_for_ait(self):
setChannelInfo(None, None, None, None, None)
service = self._session.nav.getCurrentService()
- info = service and service.info()
+ info = service and service.info()
if info is not None:
- sid = info.getInfo(iServiceInformation.sSID)
+ sid = info.getInfo(iServiceInformation.sSID)
onid = info.getInfo(iServiceInformation.sONID)
tsid = info.getInfo(iServiceInformation.sTSID)
name = info.getName()
if name is None:
name = ""
- orgid = 0
- namelen = len(name)
- for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
- if x[0] in (1, -1) :
- orgid = x[3]
- break
- setChannelInfo(sid, onid, tsid, name, orgid)
+
+ pmtid = info.getInfo(iServiceInformation.sPMTPID)
+ demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
+
+ from aitreader import eAITSectionReader
+ reader = eAITSectionReader(demux, pmtid, sid)
+ if reader.doOpen(info, self.mVuplusBox):
+ reader.doParseApplications()
+ reader.doDump()
+ else: print "no data!!"
+
+ try:
+ self._applicationList = reader.getApplicationList()
+ if len(self._applicationList) > 0:
+ orgid = int(self._applicationList[0]["orgid"])
+ setChannelInfo(sid, onid, tsid, name, orgid)
+ return self._applicationList[0]["name"]
+ except: pass
+ return None
def _cb_hbbtv_activated(self, title=None, url=None):
if not self._is_browser_running():
message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
- self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
+ self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
return
service = self._session.nav.getCurrentlyPlayingServiceReference()
setBeforeService(service)
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
def _start_opera(self):
if not self._is_browser_running():
global HBBTVAPP_PATH
- start_command = '%s/launcher start'%(HBBTVAPP_PATH)
+ global __gval__
+ start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
os.system(start_command)
+ return True
def _stop_opera(self):
global HBBTVAPP_PATH
try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
except: pass
+ return True
def _restart_opera(self):
global HBBTVAPP_PATH
- try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
+ global __gval__
+ try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
except: pass
+ return True
def getStartHbbTVUrl(self):
- url, self._urls, self._profile = None, None, 0
- service = self._session.nav.getCurrentService()
- info = service and service.info()
- if not info: return None
- self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
- for u in self._urls:
- if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
- url = u[2]
- self._profile = u[5]
+ url, self._profile = None, 0
+ if self._applicationList is not None:
+ for u in self._applicationList:
+ if u["control"] in (1, -1):
+ url = u["url"]
+ self._profile = u["profile"]
if url is None:
- url = info.getInfoString(iServiceInformation.sHBBTVUrl)
+ service = self._session.nav.getCurrentService()
+ info = service and service.info()
+ if info:
+ url = info.getInfoString(iServiceInformation.sHBBTVUrl)
return url
def showApplicationSelectionBox(self):
applications = []
if self.getStartHbbTVUrl():
- for x in self._urls:
- applications.append((x[1], x))
+ for x in self._applicationList:
+ applications.append((x["name"], x))
else: applications.append((_("No detected HbbTV applications."), None))
self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
def _application_selected(self, selected):
+ print selected
try:
if selected[1] is None: return
- self._cb_hbbtv_activated(selected[1][1], selected[1][2])
+ self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
except Exception, ErrMsg: print ErrMsg
- def showBrowserConfigBox(self):
+ def showBrowserConfigBox(self, callback=None):
start_stop_mode = []
+ self._callbackStartStop = callback
if self._is_browser_running():
start_stop_mode.append((_('Stop'),'Stop'))
else: start_stop_mode.append((_('Start'),'Start'))
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':
return False
serviceList = eServiceCenter.getInstance().list(root)
if serviceList is None:
- return False
+ return False
while True:
service = serviceList.getNext()
if service is None or not service.valid():
if len(serviceRefItems) < 5:
continue
- sid = serviceRefItems[3]
+ sid = serviceRefItems[3]
tsid = serviceRefItems[4]
if sid == _sid and tsid == _tsid:
self._session.nav.playService(eServiceReference(serviceRef))
def __init__(self):
self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
self._start = None
- self._type = None
+ self._type = None
self._keymap = None
self._read()
def _read(self):
}
class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
- skin= """
- <screen position="center,center" size="600,350" title="Preference">
+ skin = """
+ <screen position="center,120" size="600,350" title="Preference">
<widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
<widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
<widget source="key_green" render="Label" position="150,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
</screen>
"""
- def __init__(self, session, currentUrl):
- self.session = session
+ def __init__(self, session, currentUrl):
+ self.session = session
Screen.__init__(self, session)
self.menulist = []
ConfigListScreen.__init__(self, self.menulist)
self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
- "red" : self.keyRed,
- "green" : self.keyGreen,
- "ok" : self.keyOK,
+ "red" : self.keyRed,
+ "green" : self.keyGreen,
+ "ok" : self.keyOK,
"cancel" : self.keyRed
- }, -2)
- self["key_red"] = StaticText(_("Cancel"))
+ }, -2)
+ self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
- self["url"] = Label()
+ self["url"] = Label()
self._currentPageUrl = currentUrl
if self._currentPageUrl is None:
self._currentPageUrl = ''
- self._startPageUrl = None
+ self._startPageUrl = None
self._keymapType = None
self.makeMenuEntry()
self.onLayoutFinish.append(self.layoutFinished)
if not strIsEmpty(self._currentPageUrl):
l.append(("current", _("Current Page")))
l.append(("direct", _("Direct Input")))
- self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
- self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
+ self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
+ self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
kl = self.getKeymapTypeList()
class BookmarkEditWindow(ConfigListScreen, Screen):
CATEGORY,BOOKMARK = 0,1
- skin= """
+ skin = """
<screen position="center,center" size="600,140" title="Bookmark Edit">
<widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
self.mMode = _mode
self.mType = _type
self.mData = _data
- self.mSession = session
+ self.mSession = session
self.mBookmarkManager = _bm
if _data is not None:
ConfigListScreen.__init__(self, self.menulist)
self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
- "ok" : self.keyGreen,
- "green" : self.keyGreen,
- "red" : self.keyRed,
+ "ok" : self.keyGreen,
+ "green" : self.keyGreen,
+ "red" : self.keyRed,
"cancel" : self.keyRed,
- }, -2)
+ }, -2)
- self["VKeyIcon"] = Pixmap()
- self["key_red"] = StaticText(_("Cancel"))
+ self["VKeyIcon"] = Pixmap()
+ self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self.menuItemTitle = None
return None
def showMessageBox(self, text):
- msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
+ msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the") + " " + text + "."
self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
return False
else:
if self.mMode == _('Add'):
bookmarkTitle = self.menuItemTitle.value
- bookmarkUrl = self.menuItemUrl.value
+ bookmarkUrl = self.menuItemUrl.value
if strIsEmpty(bookmarkTitle):
self["config"].setCurrentIndex(0)
return self.showMessageBox(_("Bookmark Title"))
self["config"].setCurrentIndex(1)
return self.showMessageBox(_("Bookmark URL"))
self.mData.mTitle = self.menuItemTitle.value
- self.mData.mUrl = self.menuItemUrl.value
+ self.mData.mUrl = self.menuItemUrl.value
self.mBookmarkManager.updateBookmark(self.mData)
return True
if self.mType == BookmarkEditWindow.CATEGORY:
self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
- self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
+ self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
self.menulist.append(self.menuEntryName)
else:
self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
- self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
+ self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
self.menulist.append(self.menuEntryTitle)
self.menulist.append(self.menuEntryUrl)
-
+
self["config"].list = self.menulist
self["config"].l.setList(self.menulist)
class OperaBrowserBookmarkWindow(Screen):
- skin = """
- <screen name="HbbTVBrowserBookmarkWindow" position="center,center" size="600,400" title="Bookmark" >
+ skin = """
+ <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
<widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
<ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
"""
def __init__(self, _session, _url=None, _title=None):
- self.mUrl = _url
+ self.mUrl = _url
self.mTitle = _title
self.mBookmarkManager = BookmarkManager.getInstance()
self.mSession = _session
"ok" : self.keyOK,
"cancel": self.keyCancel,
"red" : self.keyRed,
- "green" : self.keyGreen,
+ "green" : self.keyGreen,
"yellow": self.keyYellow,
"blue" : self.keyBlue,
- "0" : self.keyNumber,
+ "0" : self.keyNumber,
},-2)
self["key_red"] = StaticText(_("Exit"))
self.mBookmarkList = self.setBookmarkList()
self["bookmarklist"].setList(self.mBookmarkList)
def cbEditWindow(self, ret=False):
- if not ret:
+ if not ret:
return
self.updateBookmarkList()
def getParentCategory(self):
class BrowserHelpWindow(Screen, HelpableScreen):
MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
- skin = """
- <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
+ skin = """
+ <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
<ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
<widget source="key_green" render="Label" position="155,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
<widget source="key_yellow" render="Label" position="305,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
<widget source="key_blue" render="Label" position="450,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
- </screen>
+ </screen>
"""
- def __init__(self, session):
- Screen.__init__(self, session)
+ def __init__(self, session):
+ Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_red"] = StaticText(_("Exit"))
"ok" : self.keyRed,
"cancel": self.keyRed,
"red" : self.keyRed,
- "green" : self.keyGreen,
+ "green" : self.keyGreen,
"yellow": self.keyYellow,
"blue" : self.keyBlue,
},-2)
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 = """
- <screen name="Opera Browser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
+ <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" 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="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
<widget name="menuitemHelp" position="330,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)# 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):
+ <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
+ <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
+ <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
+ </screen>
+ """ % { '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
,"menu" : self.keyMenu
}, -2)
+ self.UpdateLanguageCB()
+
self._terminatedBrowser = True
self._enableKeyEvent = True
self._currentPageUrl = None
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"
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
l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
l = [(_('Return'), None)]
- self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
+ self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
return self.lvMenuItems
def setSubListOnView(self):
command_server = getCommandServer()
try:
if self._on_close_window in command_server.onHbbTVCloseCB:
- command_server.onHbbTVCloseCB.remove(self._on_close_window)
+ command_server.onHbbTVCloseCB.remove(self._on_close_window)
except Exception, ErrMsg: pass
try:
if self._on_setPageTitle in command_server.onSetPageTitleCB:
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()
return
self.setTitle(title)
- def cbUrlText(self, data=None, mode=0):
+ def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
+ global _g_helper
+ if not _g_helper._is_browser_running():
+ return
print "Inputed Url :", data, mode
if strIsEmpty(data):
return
#self.hideSubmenu()
command_server = getCommandServer()
if self._on_setPageTitle not in command_server.onSetPageTitleCB:
- command_server.onSetPageTitleCB.append(self._on_setPageTitle)
+ command_server.onSetPageTitleCB.append(self._on_setPageTitle)
if self._on_close_window not in command_server.onHbbTVCloseCB:
command_server.onHbbTVCloseCB.append(self._on_close_window)
self.toggleMainScreen()
self.enableRCMouse(True)
+
fbClass.getInstance().lock()
eRCInput.getInstance().lock()
+
+ #setResolution(1280, 720)
+
command_util = getCommandUtil()
- command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
+ command_util.sendCommand(opcode, data, mode)
self._terminatedBrowser = False
self._enableKeyEvent = False
+ global __gval__
+ __gval__.hbbtv_handelr._soft_volume = -1
+
def _on_close_window(self):
self._onCloseTimer.start(1000)
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):
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:
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
#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
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 = """
+ <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
+ <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
+ <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
+ <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
+ <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
+ <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
+ <widget source="key_green" render="Label" position="400,80" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
+ <widget source="key_yellow" render="Label" position="400,120" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
+ </screen>
+ """
+ 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= """
+ <screen position="center,center" size="600,140" title="YouTube TV Settings">
+ <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
+
+ <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
+ <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
+
+ <widget source="key_red" render="Label" position="310,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
+ <widget source="key_green" render="Label" position="150,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
+ </screen>
+ """
+ def __init__(self, session):
+ self.session = session
+ Screen.__init__(self, session)
+
+ self.menulist = []
+ ConfigListScreen.__init__(self, self.menulist)
+
+ self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
+ "ok" : self.keyGreen,
+ "green" : self.keyGreen,
+ "red" : self.keyRed,
+ "cancel" : self.keyRed,
+ }, -2)
+
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("Save"))
+
+ self.makeConfigList()
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('YouTube TV Settings'))
+
+ def keyGreen(self):
+ config.plugins.youtubetv.showhelp.save()
+ config.plugins.youtubetv.uri.save()
+ config.plugins.youtubetv.save()
+ config.plugins.save()
+ self.close()
+ def keyRed(self):
+ config.plugins.youtubetv.showhelp.cancel()
+ config.plugins.youtubetv.uri.cancel()
+ self.close()
+
+ def keyLeft(self):
+ ConfigListScreen.keyLeft(self)
+
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
+
+ def makeConfigList(self):
+ self.menulist = []
+ entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
+ entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Starter again"), config.plugins.youtubetv.showhelp)
+ self.menulist.append(entryUri)
+ self.menulist.append(entryShowHelp)
+
+ self["config"].list = self.menulist
+ self["config"].l.setList(self.menulist)
+
def auto_start_main(reason, **kwargs):
if reason:
command_server = getCommandServer()
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)
self["helpActions"] = ActionMap(["HelpbuttonActions"], {
"help_b" : self.showHelp,
- "help_l" : self.showManual,
+ "help_l" : self.showManual,
}, -2)
_g_clearBrowserDataTimer = eTimer()
try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
except: pass
setPluginBrowser(None)
+
def clearBrowserData():
_g_clearBrowserDataTimer.callback.append(_do_clean)
_g_clearBrowserDataTimer.start(50)
setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
+_g_backupSession = None
+def showYoutubeTV(session, **kwargs):
+ def _do_clean():
+ _g_clearBrowserDataTimer.stop()
+ try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
+ except: pass
+ setPluginBrowser(None)
+ global _g_backupSession
+
+ service = getBeforeService()
+ if service is not None:
+ _g_backupSession.nav.playService(eServiceReference(service))
+ _g_backupSession = None
+ def clearBrowserData():
+ _g_clearBrowserDataTimer.callback.append(_do_clean)
+ _g_clearBrowserDataTimer.start(50)
+ def cbYoutubeTVClose(ret):
+ if ret:
+ global _g_backupSession
+ _g_backupSession = session
+ service = session.nav.getCurrentlyPlayingServiceReference()
+ if service is not None:
+ setBeforeService(service.toString())
+ session.nav.stopService()
+ else: setBeforeService(service)
+ setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
+ if config.plugins.youtubetv.showhelp.value == True:
+ cbYoutubeTVClose(True)
+ else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
+
+def youtube_setting_main(session, **kwargs):
+ session.open(YoutubeTVSettings)
+
+def start_menu_main(menuid, **kwargs):
+ if menuid == "mainmenu":
+ return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
+ return []
+
def plugin_start_main(session, **kwargs):
#session.open(OperaBrowser)
def _do_clean():
def plugin_extension_start_application(session, **kwargs):
global _g_helper
- if _g_helper is None:
+ if _g_helper is None:
return
_g_helper.showApplicationSelectionBox()
def plugin_extension_browser_config(session, **kwargs):
global _g_helper
- if _g_helper is None:
+ if _g_helper is None:
return
_g_helper.showBrowserConfigBox()
def Plugins(path, **kwargs):
l = []
l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
+ l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
+ l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
projects / vuplus_dvbapp / blobdiff