X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FPlugins%2FExtensions%2FHbbTV%2Fplugin.py;h=6d51dde496d11aee22d7136110c749d22f25eb44;hp=9ae4d2e99fa0cf0804e3938fbc888a92cf0b543b;hb=3d5f795eba816f4ef9e487cefe6e12f1b5c589c4;hpb=0da688aba6cca5cc5b0b4406e384fa9e3345859c
diff --git a/lib/python/Plugins/Extensions/HbbTV/plugin.py b/lib/python/Plugins/Extensions/HbbTV/plugin.py
index 9ae4d2e..6d51dde 100644
--- a/lib/python/Plugins/Extensions/HbbTV/plugin.py
+++ b/lib/python/Plugins/Extensions/HbbTV/plugin.py
@@ -6,27 +6,37 @@ from Screens.ChoiceBox import ChoiceBox
from Screens.MessageBox import MessageBox
from Screens.InfoBarGenerics import InfoBarNotifications
from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
+from Screens.ChannelSelection import service_types_tv
+from Components.Language import language
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.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
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.Pixmap import Pixmap
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
+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
+
+from bookmark import BookmarkManager, BookmarkData, CategoryData
import os, struct, threading, stat, select, time, socket, select
+from __init__ import _
+
strIsEmpty = lambda x: x is None or len(x) == 0
HBBTVAPP_PATH = "/usr/local/hbb-browser"
COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
+_g_helper = None
+
class GlobalValues:
command_util = None
command_server = None
@@ -44,8 +54,53 @@ class GlobalValues:
packet_m = 0xBBADBEE
packet_h = '!IIII'
packet_hl = struct.calcsize(packet_h)
+
+ 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
+def getPluginBrowser():
+ global __gval__
+ return __gval__.plugin_browser
+
def getPacketHeaders():
global __gval__
return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
@@ -73,6 +128,15 @@ def getChannelInfos():
__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
@@ -126,8 +190,8 @@ class MMSStreamURL:
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)
+ #print "Request."
+ #print self.sendmsg%(location, host)
fullydata = ''
while 1:
res = sock.recv(1024)
@@ -165,6 +229,8 @@ class OpCodeSet:
,"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
@@ -174,7 +240,22 @@ class OpCodeSet:
,"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
}
self._opstr_ = {
0x0000 : "OP_UNKNOWN"
@@ -184,6 +265,8 @@ class OpCodeSet:
,0x0004 : "OP_HBBTV_UNLOAD_AIT"
,0x0005 : "OP_HBBTV_FULLSCREEN"
,0x0006 : "OP_HBBTV_TITLE"
+ ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
+ ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
@@ -193,7 +276,22 @@ class OpCodeSet:
,0x0204 : "OP_VOD_PAUSE"
,0x0205 : "OP_VOD_STATUS"
,0x0206 : "OP_VOD_FORBIDDEN"
+ ,0x0207 : "OP_VOD_STOPED"
+ ,0x0208 : "OP_VOD_SPEED_CTRL"
+ ,0x0209 : "OP_VOD_SEEK_CTRL"
,0x0301 : "OP_BROWSER_OPEN_URL"
+ ,0x0309 : "OP_BROWSER_VKBD_REQ"
+ ,0x030A : "OP_BROWSER_VKBD_RES"
+ ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
+ ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
+ ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
+ ,0x030E : "OP_BROWSER_MENU_REQ"
+ ,0x030F : "OP_BROWSER_MENU_RES"
+ ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
+ ,0x0401 : "OP_DVBAPP_VOL_UP"
+ ,0x0402 : "OP_DVBAPP_VOL_DOWN"
+ ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
+ ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
}
def get(self, opstr):
@@ -289,9 +387,12 @@ class StreamServer:
class ServerFactory:
def doListenUnixTCP(self, name, handler):
def destroy(name):
- if os.path.exists(name):
- os.unlink(name)
- print "Removed ", name
+ import os
+ try:
+ if os.path.exists(name):
+ os.unlink(name)
+ print "Removed ", name
+ except: pass
destroy(name)
params = SocketParams()
@@ -306,11 +407,11 @@ class ServerFactory:
return streamServer
def doListenInetTCP(self, ip, port, handler):
- print "not implemented yet!!"
+ print "Not implemented yet!!"
def doListenUnixDGRAM(self, name, handler):
- print "not implemented yet!!"
+ print "Not implemented yet!!"
def doListenInetDGRAM(self, ip, port, handler):
- print "not implemented yet!!"
+ print "Not implemented yet!!"
class Handler:
def doUnpack(self, data):
@@ -338,18 +439,17 @@ class BrowserCommandUtil(OpCodeSet):
def doConnect(self, filename):
if not os.path.exists(filename):
- print "file not 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
+ 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):
@@ -360,7 +460,7 @@ class BrowserCommandUtil(OpCodeSet):
def doSend(self, command, params=None, reserved=0):
if self._fd is None:
- print "connected pipe was not exists!!"
+ print "No found pipe!!"
return False
data = ''
try:
@@ -388,6 +488,8 @@ class HandlerHbbTV(Handler):
self.handle_map = {
0x0001 : self._cb_handleCloseHbbTVBrowser
,0x0006 : self._cb_handleSetPageTitle
+ ,0x0009 : self._cb_handleHbbTVRetryOpen
+ ,0x000A : self._cb_handleHbbTVChangeChannel
,0x0101 : self._cb_handleGetChannelInfoForUrl
,0x0102 : self._cb_handleGetChannelInfoForAIT
,0x0103 : self._cb_handleGetChannelInfoList
@@ -395,12 +497,26 @@ class HandlerHbbTV(Handler):
,0x0202 : self._cb_handleVODPlayerPlay
,0x0203 : self._cb_handleVODPlayerStop
,0x0204 : self._cb_handleVODPlayerPlayPause
+ ,0x0401 : self._cb_handleDVBAppVolUp
+ ,0x0402 : self._cb_handleDVBAppVolDown
+ ,0x0208 : self._cb_handleVODSpeedCtrl
+ ,0x0209 : self._cb_handleVODSeekCtrl
+ ,0x0501 : self._cb_handleSystemOutOfMemory
+ ,0x0502 : self._cb_handleSystemNotufyMyPID
+ ,0x0309 : self._cb_handleShowVirtualKeyboard
+ ,0x030B : self._cb_handlePasteVirtualKeyboard
+ ,0x030E : self._cb_handleBrowserMenuReq
}
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()
+ self._timer_paste_vkbd = eTimer()
+ self._curren_title = None
+
def _handle_dump(self, handle, opcode, data=None):
if True: return
print str(handle)
@@ -437,6 +553,146 @@ class HandlerHbbTV(Handler):
self._on_set_title_cb = None
return self.doPack(opcode, params, reserved)
+ def _cb_handleHbbTVChangeChannel(self, opcode, data):
+ self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
+ global _g_helper
+ if _g_helper is None:
+ return (0, "NOK")
+ dataItems = data.split(":")
+ sid = dataItems[0]
+ tsid = dataItems[1]
+ if not _g_helper.doChangeChannel(sid, tsid):
+ return (0, "NOK")
+ return (0, "OK")
+
+ def _cb_handleBrowserMenuReq(self, opcode, data):
+ self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
+ restoreResolution()
+ fbClass.getInstance().unlock()
+ eRCInput.getInstance().unlock()
+ browser = getPluginBrowser()
+ if browser is not None:
+ browser.setCurrentPageUrl(data, self._curren_title)
+ return (0, "OK")
+
+ def _cb_handlePasteVirtualKeyboard(self, opcode, data):
+ self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
+ def _cb_PasteRefocusVirtualKeyboard():
+ self._timer_paste_vkbd.stop()
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
+ try:
+ self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
+ except: pass
+ def _cb_PasteKeyVirtualKeyboard():
+ self._timer_paste_vkbd.stop()
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
+ try:
+ self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
+ except: pass
+ self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
+ self._timer_paste_vkbd.start(100)
+ def _cb_PasteMouseVirtualKeyboard():
+ self._timer_paste_vkbd.stop()
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
+ #time.sleep(1)
+ #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
+ try:
+ self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
+ except: pass
+ #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
+ #self._timer_paste_vkbd.start(1000)
+ self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
+ self._timer_paste_vkbd.start(50)
+ return (0, "OK")
+
+ 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):
+ data = ""
+ self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
+ return (0, "OK")
+
+ def _cb_handleVODSeekCtrl(self, opcode, data):
+ self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
+ headLen = struct.calcsize('!I')
+ unpackedData = struct.unpack('!I', data[:headLen])
+ seekTime = unpackedData[0]
+ service = self._session.nav.getCurrentService()
+ seekable = service.seek()
+ if seekable is None or not seekable.isCurrentlySeekable():
+ raise Exception("This stream is not support manual seek.")
+ pts = seekTime
+ seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
+ return (0, "OK")
+
+ 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
+ try:
+ self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
+ except: pass
+ 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_handleVODSpeedCtrl(self, opcode, data):
+ self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
+ headLen = struct.calcsize('!I')
+ unpackedData = struct.unpack('!I', data[:headLen])
+ playSpeed = unpackedData[0]
+ service = self._session.nav.getCurrentService()
+ pauseable = service.pause()
+ if playSpeed > 2:
+ playSpeed = 2
+ if pauseable.setFastForward(playSpeed) == -1:
+ pauseable.setFastForward(1)
+ raise Exception("This stream is not support trick play.")
+ 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()
@@ -457,19 +713,24 @@ class HandlerHbbTV(Handler):
return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
def _cb_handleSetPageTitle(self, opcode, data):
- self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
+ self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
if data.startswith('file://') or data.startswith('http://'):
return "OK"
if self._on_set_title_cb is not None:
for x in self._on_set_title_cb:
try:
x(data)
+ self._curren_title = 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()
+ try:
+ self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
+ except: pass
self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
if self._on_close_cb:
@@ -486,6 +747,9 @@ class HandlerHbbTV(Handler):
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):
@@ -516,7 +780,8 @@ class HandlerHbbTV(Handler):
for ii in range(5):
self._vod_service = None
try:
- print "try to open vod [%d] : %s" % (ii, url)
+ #print "Try to open vod [%d] : %s" % (ii, url)
+ print "Try to open vod"
self._vod_service = eServiceReference(4097, 0, url)
self._session.nav.playService(self._vod_service)
if self._vod_service is not None:
@@ -552,23 +817,30 @@ class HandlerHbbTV(Handler):
print "onPause ERR :", ErrMsg
return (0, "OK")
+from libshm import SimpleSharedMemory
+_g_ssm_ = None
class HbbTVWindow(Screen, InfoBarNotifications):
skin = """
"""
- def __init__(self, session, url=None, cbf=None, useAIT=False):
+ 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,
})
self._url = url
self._use_ait = useAIT
+ self._profile = profile
self._cb_closed_func = cbf
self.onLayoutFinish.append(self._layoutFinished)
@@ -582,10 +854,60 @@ class HbbTVWindow(Screen, InfoBarNotifications):
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):
+ (position,length) = self.getVodPlayTime()
+ self._ssm.setStatus(length, length, 1)
+ print "service EOF"
+ self._currentServicePositionTimer.stop()
+
def _layoutFinished(self):
+ self.setTitle(_('HbbTV Plugin'))
command_util = getCommandUtil()
+ profile = self._profile
(sid, onid, tsid, name, orgid) = getChannelInfos()
- params = struct.pack('!IIIII', orgid, 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)
@@ -613,13 +935,15 @@ class HbbTVWindow(Screen, InfoBarNotifications):
if self._cb_closed_func is not None:
self._cb_closed_func()
except: pass
+ restoreResolution()
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
self.close()
def _serviceForbiden(self):
global __gval__
real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
- print "Received URI :\n",real_url
+ #print "Received URI :\n", real_url
if real_url is not None:
__gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
@@ -638,19 +962,28 @@ class HbbTVHelper(Screen):
__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._restart_opera()
+
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()
+ global _g_ssm_
+ if _g_ssm_ is None:
+ _g_ssm_ = SimpleSharedMemory()
+ _g_ssm_.doConnect()
+
+ self._callbackStartStop = None
+
def _cb_registrate_infobar(self):
if InfoBar.instance:
self._timer_infobar.stop()
@@ -679,21 +1012,22 @@ class HbbTVHelper(Screen):
orgid = 0
namelen = len(name)
for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
- if x[0] == 1 :
+ 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)
+ 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
@@ -705,14 +1039,18 @@ class HbbTVHelper(Screen):
print "already excuted opera browser!!"
return
- use_ait = False
+ 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._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
def _cb_closed_browser(self):
self._excuted_browser = False
@@ -722,31 +1060,40 @@ class HbbTVHelper(Screen):
global HBBTVAPP_PATH
start_command = '%s/launcher start'%(HBBTVAPP_PATH)
os.system(start_command)
+ return True
def _stop_opera(self):
global HBBTVAPP_PATH
try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
except: pass
+ def _restart_opera(self):
+ global HBBTVAPP_PATH
+ try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
+ except: pass
+ return True
+
def getStartHbbTVUrl(self):
- url, self._urls = None, None
+ 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] == 1: # 0:control code, 1:name, 2:url, 3:orgid, 4:appid
+ 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))
+ 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):
@@ -755,18 +1102,21 @@ class HbbTVHelper(Screen):
self._cb_hbbtv_activated(selected[1][1], selected[1][2])
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',None))
- else: start_stop_mode.append(('Start',None))
+ start_stop_mode.append((_('Stop'),'Stop'))
+ else: start_stop_mode.append((_('Start'),'Start'))
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
+ if self._callbackStartStop is not None:
+ self._callbackStartStop()
try:
- mode = selected[0]
+ mode = selected[1]
if mode == 'Start':
if not self._is_browser_running():
self._start_opera()
@@ -783,7 +1133,630 @@ class HbbTVHelper(Screen):
print "Check Browser Running ERR :", ErrMsg
return False
-_g_helper = None
+ def doChangeChannel(self, _sid, _tsid):
+ root = eServiceReference(service_types_tv)
+ if root is None:
+ return False
+ serviceList = eServiceCenter.getInstance().list(root)
+ if serviceList is None:
+ return False
+ while True:
+ service = serviceList.getNext()
+ if service is None or not service.valid():
+ break
+
+ #1:0:19:2840:3FB:1:C00000:0:0:0:
+ serviceRef = service.toString()
+ if strIsEmpty(serviceRef):
+ continue
+ serviceRefItems = serviceRef.split(":")
+ if len(serviceRefItems) < 5:
+ continue
+
+ sid = serviceRefItems[3]
+ tsid = serviceRefItems[4]
+ if sid == _sid and tsid == _tsid:
+ self._session.nav.playService(eServiceReference(serviceRef))
+ service = self._session.nav.getCurrentlyPlayingServiceReference()
+ setBeforeService(service)
+ return True
+ return False
+
+class OperaBrowserSetting:
+ def __init__(self):
+ self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
+ self._start = None
+ self._type = None
+ self._keymap = None
+ self._read()
+ def _read(self):
+ f = open(self._settingFileName)
+ for line in f.readlines():
+ if line.startswith('start='):
+ tmp = line[6:len(line)-1].split()
+ self._start = tmp[0]
+ if len(tmp) > 1:
+ self._type = int(tmp[1])
+ else: self._type = 0
+ elif line.startswith('keymap='):
+ self._keymap = line[7:len(line)-1]
+ f.close()
+ def _write(self):
+ tmpstr = []
+ tmpstr.append('start=%s %d\n' % (self._start, self._type))
+ tmpstr.append('keymap=%s\n' % (self._keymap))
+ f = open(self._settingFileName, 'w')
+ f.writelines(tmpstr)
+ f.close()
+ def setData(self, start, types=0, keymap="us-rc"):
+ self._start = start
+ self._type = types
+ self._keymap = keymap
+ self._write()
+ def getData(self):
+ return {
+ 'start':self._start,
+ 'type':self._type,
+ 'keymap':self._keymap,
+ }
+
+class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
+ skin= """
+
+
+
+
+
+
+
+
+
+
+ """
+ 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,
+ "cancel" : self.keyRed
+ }, -2)
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("Save"))
+ self["url"] = Label()
+
+ self._currentPageUrl = currentUrl
+ if self._currentPageUrl is None:
+ self._currentPageUrl = ''
+ self._startPageUrl = None
+ self._keymapType = None
+ self.makeMenuEntry()
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Preference'))
+
+ def updateStartPageUrl(self):
+ if self.menuItemStartpage.value == "startpage":
+ self["url"].setText(self._startPageUrl)
+ elif self.menuItemStartpage.value == "current":
+ self["url"].setText(self._currentPageUrl)
+ elif self.menuItemStartpage.value == "direct":
+ self["url"].setText('')
+
+ def keyGreen(self):
+ url = self["url"].getText()
+ if strIsEmpty(url):
+ self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
+ return
+ mode = 0
+ if url.find('/usr/local/manual') > 0:
+ mode = 1
+ self._keymapType = self.menuItemKeyboardLayout.value
+ OperaBrowserSetting().setData(url, mode, self._keymapType)
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
+ self.close()
+
+ def keyRed(self):
+ self.close()
+
+ def keyOK(self):
+ def _cb_directInputUrl(data):
+ if strIsEmpty(data):
+ return
+ self["url"].setText(data)
+ if self.menuItemStartpage.value == "direct":
+ self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
+
+ def keyLeft(self):
+ ConfigListScreen.keyLeft(self)
+ self.updateStartPageUrl()
+
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
+ self.updateStartPageUrl()
+
+ def getKeymapTypeList(self):
+ types = []
+ for f in os.listdir("/usr/local/hbb-browser/keymap"):
+ filesplit = f.split('.')
+ if len(filesplit) < 2:
+ continue
+ types.append((filesplit[1], filesplit[1]))
+ types.sort()
+ return types
+
+ def makeMenuEntry(self):
+ l = []
+ l.append(("startpage", _("Start Page")))
+ 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)
+
+ kl = self.getKeymapTypeList()
+
+ try:
+ d = OperaBrowserSetting().getData()
+ self._startPageUrl = d['start']
+ self._keymapType = d['keymap']
+ #d['type']
+ except: self._startPageUrl = 'http://vuplus.com'
+ self.updateStartPageUrl()
+
+ if self._keymapType is None or len(self._keymapType) == 0:
+ self._keymapType = "us-rc"
+ self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
+ self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
+ self.resetMenuList()
+
+ def resetMenuList(self):
+ self.menulist = []
+ self.menulist.append(self.menuEntryStartpage)
+ self.menulist.append(self.menuEntryKeyboardLayout)
+
+ self["config"].list = self.menulist
+ self["config"].l.setList(self.menulist)
+
+class BookmarkEditWindow(ConfigListScreen, Screen):
+ CATEGORY,BOOKMARK = 0,1
+ skin= """
+
+
+
+
+
+
+
+
+
+
+
+
+ """
+ def __init__(self, session, _mode, _type, _data, _bm):
+ self.mMode = _mode
+ self.mType = _type
+ self.mData = _data
+ self.mSession = session
+ self.mBookmarkManager = _bm
+
+ if _data is not None:
+ print _data.mId
+
+ 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["VKeyIcon"] = Pixmap()
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("Save"))
+
+ self.menuItemTitle = None
+ self.menuItemUrl = None
+ self.menuItemName = None
+
+ self.menuEntryName = None
+ self.menuEntryTitle = None
+ self.menuEntryUrl = None
+
+ self.makeConfigList()
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Bookmark') + ' ' + self.mMode)
+
+ def selectedItem(self):
+ currentPosition = self["config"].getCurrent()
+ if self.mType == BookmarkEditWindow.CATEGORY:
+ return (_("Name"), self.menuItemName)
+ else:
+ if currentPosition == self.menuEntryTitle:
+ return (_("Title"), self.menuItemTitle)
+ elif currentPosition == self.menuEntryUrl:
+ return (_("Url"), self.menuItemUrl)
+ return None
+
+ def showMessageBox(self, text):
+ msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
+ self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
+ return False
+
+ def showVKeyWindow(self, data=None):
+ itemTitle = ""
+ itemValue = ""
+ selected = self.selectedItem()
+ if selected is not None:
+ itemValue = selected[1].value
+ if strIsEmpty(itemValue):
+ itemValue = ""
+ itemTitle = selected[0]
+
+ self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
+
+ def cbVKeyWindow(self, data=None):
+ if data is not None:
+ selected = self.selectedItem()
+ if selected is not None:
+ selected[1].setValue(data)
+
+ def saveData(self):
+ if self.mType == BookmarkEditWindow.CATEGORY:
+ if self.mMode == _('Add'):
+ categoryName = self.menuItemName.value
+ if strIsEmpty(categoryName):
+ return self.showMessageBox(_("Category Name"))
+ self.mBookmarkManager.addCategory(categoryName)
+ else:
+ if strIsEmpty(self.menuItemName.value):
+ return self.showMessageBox(_("Category Name"))
+ self.mData.mName = self.menuItemName.value
+ self.mBookmarkManager.updateCategory(self.mData)
+ else:
+ if self.mMode == _('Add'):
+ bookmarkTitle = self.menuItemTitle.value
+ bookmarkUrl = self.menuItemUrl.value
+ if strIsEmpty(bookmarkTitle):
+ self["config"].setCurrentIndex(0)
+ return self.showMessageBox(_("Bookmark Title"))
+ if strIsEmpty(bookmarkUrl):
+ self["config"].setCurrentIndex(1)
+ return self.showMessageBox(_("Bookmark URL"))
+ self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
+ else:
+ if strIsEmpty(self.menuItemTitle.value):
+ self["config"].setCurrentIndex(0)
+ return self.showMessageBox(_("Bookmark Title"))
+ if strIsEmpty(self.menuItemUrl.value):
+ self["config"].setCurrentIndex(1)
+ return self.showMessageBox(_("Bookmark URL"))
+ self.mData.mTitle = self.menuItemTitle.value
+ self.mData.mUrl = self.menuItemUrl.value
+ self.mBookmarkManager.updateBookmark(self.mData)
+ return True
+
+ def keyGreen(self):
+ if not self.saveData():
+ return
+ self.close(True)
+ def keyRed(self):
+ self.close(False)
+ def keyLeft(self):
+ ConfigListScreen.keyLeft(self)
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
+ def makeConfigList(self):
+ self.menulist = []
+
+ 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.menulist.append(self.menuEntryName)
+ else:
+ self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
+ 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.menulist.append(self.menuEntryTitle)
+ self.menulist.append(self.menuEntryUrl)
+
+ self["config"].list = self.menulist
+ self["config"].l.setList(self.menulist)
+
+class OperaBrowserBookmarkWindow(Screen):
+ skin = """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ """
+
+ def __init__(self, _session, _url=None, _title=None):
+ self.mUrl = _url
+ self.mTitle = _title
+ self.mBookmarkManager = BookmarkManager.getInstance()
+ self.mSession = _session
+ Screen.__init__(self, _session)
+ self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
+ "ok" : self.keyOK,
+ "cancel": self.keyCancel,
+ "red" : self.keyRed,
+ "green" : self.keyGreen,
+ "yellow": self.keyYellow,
+ "blue" : self.keyBlue,
+ "0" : self.keyNumber,
+ },-2)
+
+ self["key_red"] = StaticText(_("Exit"))
+ self["key_green"] = StaticText(_("Add"))
+ self["key_yellow"] = StaticText(_("Edit"))
+ self["key_blue"] = StaticText(_("Delete"))
+ self["key_0"] = StaticText(_("Set as Startpage"))
+
+ self.mBookmarkList = self.setBookmarkList()
+ self["bookmarklist"] = MenuList(self.mBookmarkList)
+
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Bookmark'))
+
+ def setBookmarkList(self):
+ l = []
+ #self.mBookmarkManager.dump()
+ cd = self.mBookmarkManager.getBookmarkRoot()
+ for ck in cd.iterkeys():
+ l.append(('# ' + cd[ck].mName, cd[ck]))
+ bd = cd[ck].mBookmarks
+ for bk in bd.iterkeys():
+ l.append((' - ' + bd[bk].mTitle, bd[bk]))
+ return l
+ def updateBookmarkList(self):
+ self.mBookmarkList = self.setBookmarkList()
+ self["bookmarklist"].setList(self.mBookmarkList)
+ def cbEditWindow(self, ret=False):
+ if not ret:
+ return
+ self.updateBookmarkList()
+ def getParentCategory(self):
+ idx = self["bookmarklist"].getSelectedIndex()
+ try:
+ while idx >= 0:
+ data = self.mBookmarkList[idx][0].strip()
+ if data[0] == '#':
+ return self.mBookmarkList[idx][1]
+ idx -= 1
+ except: pass
+ return None
+ def isCategoryItem(self):
+ try:
+ head = self["bookmarklist"].getCurrent()[0].strip()
+ if head[0] == '#':
+ return True
+ except: pass
+ return False
+ def keyNumber(self):
+ data = self["bookmarklist"].getCurrent()[1]
+ if strIsEmpty(data.mUrl):
+ msg = _("Invalid URL. Please check again!!")
+ self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
+ return
+ def cbSetStartpage(ret=None):
+ if ret is None: return
+ if ret:
+ data = self["bookmarklist"].getCurrent()[1]
+ OperaBrowserSetting().setData(data.mUrl, data.mType)
+ msg = _("Do you want to set selected url to the Startpage?")
+ self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
+
+ def keyGreen(self):
+ def cbGreen(data):
+ if data is None:
+ return
+ if data[1] == 1:
+ parent = self.getParentCategory()
+ if parent is None:
+ return
+ if strIsEmpty(self.mTitle):
+ return
+ retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
+ if not retAdd:
+ msg = _("Current page is already exist.")
+ self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
+ self.cbEditWindow(True)
+ elif data[1] == 2:
+ parent = self.getParentCategory()
+ if parent is None:
+ return
+ b = BookmarkData(0, '', '', parent.mId, 0)
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
+ elif data[1] == 3:
+ c = CategoryData(0, '')
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
+ if strIsEmpty(self.mUrl):
+ l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
+ else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
+ self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
+ def keyYellow(self):
+ data = self["bookmarklist"].getCurrent()[1]
+ if self.isCategoryItem():
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
+ else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
+ def keyBlue(self):
+ def cbBlue(ret=None):
+ if not ret: return
+ data = self["bookmarklist"].getCurrent()[1]
+ if self.isCategoryItem():
+ self.mBookmarkManager.deleteCategory(data.mId)
+ else: self.mBookmarkManager.deleteBookmark(data.mId)
+ self.updateBookmarkList()
+ if self.isCategoryItem():
+ msg = _("Do you want to delete the category and the bookmarks?")
+ else: msg = _("Do you want to delete the bookmark?")
+ self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
+ def keyOK(self):
+ if self.isCategoryItem(): return
+
+ data = self["bookmarklist"].getCurrent()[1]
+ url = data.mUrl.strip()
+ if len(url) == 0:
+ self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
+ return
+ mode = data.mType
+ if mode:
+ lang = language.getLanguage()
+ if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
+ url = '/usr/local/manual/ru_RU/main.html'
+ elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
+ url = '/usr/local/manual/de_DE/main.html'
+ self.close((url, mode))
+ def keyRed(self):
+ self.keyCancel()
+ def keyCancel(self):
+ self.close()
+
+class BrowserHelpWindow(Screen, HelpableScreen):
+ MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
+ skin = """
+
+
+
+
+
+
+
+
+
+
+
+ """
+ def __init__(self, session):
+ Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
+
+ self["key_red"] = StaticText(_("Exit"))
+ self["key_green"] = StaticText(_("Global"))
+ self["key_yellow"] = StaticText(_("Mouse"))
+ self["key_blue"] = StaticText(_("Keyboard"))
+
+ self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
+ "ok" : self.keyRed,
+ "cancel": self.keyRed,
+ "red" : self.keyRed,
+ "green" : self.keyGreen,
+ "yellow": self.keyYellow,
+ "blue" : self.keyBlue,
+ },-2)
+
+ self.showHelpTimer = eTimer()
+ self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
+ self.showHelpTimer.start(500)
+
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Browser Help'))
+
+ def cbShowHelpTimerClosed(self):
+ self.showHelpTimer.stop()
+ self.setHelpModeActions(self.MODE_GLOBAL)
+
+ def setHelpModeActions(self, _mode=0):
+ self.helpList = []
+ if _mode == self.MODE_GLOBAL:
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
+ "cancel" : (self.keyPass, _("Exit the Opera browser.")),
+ })
+ self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
+ "menu" : (self.keyPass, _("Show the Menu window.")),
+ })
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
+ "green" : (self.keyPass, _("Enter Key")),
+ "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
+ "blue" : (self.keyPass, _("Backspace Key")),
+ })
+ self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
+ "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
+ })
+
+ elif _mode == self.MODE_MOUSE:
+ self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
+ "up" : (self.keyPass, _("It will move the mouse pointer up.")),
+ "down" : (self.keyPass, _("It will move the mouse pointer down.")),
+ "left" : (self.keyPass, _("It will move the mouse pointer left.")),
+ "right" : (self.keyPass, _("It will move the mouse pointer right.")),
+ })
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
+ "ok" : (self.keyPass, _("Left Mouse Button")),
+ })
+ self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
+ "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
+ "nextService" : (self.keyPass, _("Left Key")),
+ "prevService" : (self.keyPass, _("Right Key")),
+ })
+ elif _mode == self.MODE_KEYBOARD:
+ self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
+ "up" : (self.keyPass, _("Up Key")),
+ "down" : (self.keyPass, _("Down Key")),
+ "left" : (self.keyPass, _("Left Key")),
+ "right" : (self.keyPass, _("Right Key")),
+ })
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
+ "ok" : (self.keyPass, _("Enter Key")),
+ })
+ self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
+ "nextBouquet" : (self.keyPass, _("PageUp Key")),
+ "prevBouquet" : (self.keyPass, _("PageDown Key")),
+ "nextService" : (self.keyPass, _("Go to previous page.")),
+ "prevService" : (self.keyPass, _("Go to next page.")),
+ })
+
+ if _mode > 0:
+ self.showHelp()
+
+ def keyPass(self):
+ pass
+
+ def keyRed(self):
+ self.close()
+ def keyGreen(self):
+ self.setHelpModeActions(self.MODE_GLOBAL)
+ def keyYellow(self):
+ self.setHelpModeActions(self.MODE_MOUSE)
+ def keyBlue(self):
+ self.setHelpModeActions(self.MODE_KEYBOARD)
+
class OperaBrowser(Screen):
MENUBAR_ITEM_WIDTH = 150
MENUBAR_ITEM_HEIGHT = 30
@@ -791,32 +1764,50 @@ class OperaBrowser(Screen):
SUBMENULIST_HEIGHT = 25
SUBMENULIST_NEXT = 2
+ # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
+ # menulist->size->x : SUBMENULIST_WIDTH
+ # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
+ # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
+ # submenulist->size->x : SUBMENULIST_WIDTH
+
+ size = getDesktop(0).size()
+ WIDTH = int(size.width())
+ HEIGHT = int(size.height())
skin = """
-
+
-
-
-
-
-
- """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)
-
- MENUITEMS_LIST =[[('Open Location', None), ('Start/Stop',None), ('Exit', None)],
- [('About', None)]]
- def __init__(self, session):
+
+
+
+
+
+
+ """ % { 'width' :WIDTH,
+ 'height' :HEIGHT,
+ 'bottom_pos_y' :HEIGHT-80,
+ 'bottom_size_x' :WIDTH }
+
+ COMMAND_MAP = {}
+ MENUITEMS_LIST =[]
+ def __init__(self, session, url=None):
Screen.__init__(self, session)
-
- self["actions"] = ActionMap(["MinuteInputActions", "ColorActions", "InputActions", "InfobarChannelSelection", "EPGSelectActions", "KeyboardInputActions"], {
+ self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
"cancel" : self.keyCancel
,"ok" : self.keyOK
,"left" : self.keyLeft
,"right" : self.keyRight
,"up" : self.keyUp
,"down" : self.keyDown
- ,"menu" : self.keyCancel
+ ,"menu" : self.keyMenu
}, -2)
+ self.UpdateLanguageCB()
+
+ self._terminatedBrowser = True
+ self._enableKeyEvent = True
+ self._currentPageUrl = None
+ self._currentPageTitle = None
self.menubarCurrentIndex = 0
self.lvMenuItems = []
self.lvSubMenuItems = []
@@ -824,7 +1815,8 @@ class OperaBrowser(Screen):
self["topArea"] = Label()
self["bottomArea"] = Label()
- self["menuitemFile"] = MultiColorLabel()
+ self["menuitemFile"] = MultiColorLabel()# modify menu
+ self["menuitemTool"] = MultiColorLabel()
self["menuitemHelp"] = MultiColorLabel()
self["menulist"] = MenuList(self.setListOnView())
@@ -840,25 +1832,51 @@ class OperaBrowser(Screen):
self._onCloseTimer = eTimer()
self._onCloseTimer.callback.append(self._cb_onClose)
+ self.paramUrl = url
+ 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 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["menuitemFile"].setText(_("File"))# modify menu
+ self["menuitemTool"].setText(_("Tools"))
+ self["menuitemHelp"].setText(_("Help"))
self["menulist"].hide()
self["submenulist"].hide()
- self["bottomArea"].setText("Opera Web Browser Plugin v0.1")
- self.setTitle("BrowserMain")
+ self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
+ self.setTitle(_("BrowserMain"))
self.selectMenuitem()
+ if self.paramUrl is not None:
+ self.keyMenu()
+ self.cbUrlText(self.paramUrl, 1)
+
def selectMenuitem(self):
- tmp = [self["menuitemFile"], self["menuitemHelp"]]
+ tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
self["menuitemFile"].setForegroundColorNum(0)
+ self["menuitemTool"].setForegroundColorNum(0)
self["menuitemHelp"].setForegroundColorNum(0)
tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
@@ -869,7 +1887,10 @@ class OperaBrowser(Screen):
self.keyCancel()
def setListOnView(self):
- self.lvMenuItems = self.MENUITEMS_LIST[self.menubarCurrentIndex]
+ 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]
return self.lvMenuItems
def setSubListOnView(self):
@@ -917,21 +1938,38 @@ class OperaBrowser(Screen):
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._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()
+ else:
+ self.keyRight()
+ self.keyLeft()
def _on_setPageTitle(self, title=None):
- print "page title :",title
+ print "Title :",title
if title is None:
return
self.setTitle(title)
- def cbUrlText(self, data=None):
- print "Inputed Url :", data
+ def cbUrlText(self, data=None, mode=0):
+ 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)
@@ -939,41 +1977,92 @@ class OperaBrowser(Screen):
command_server.onHbbTVCloseCB.append(self._on_close_window)
self.toggleMainScreen()
self.enableRCMouse(True)
+
+ fbClass.getInstance().lock()
eRCInput.getInstance().lock()
+
+ setResolution(1280, 720)
+
command_util = getCommandUtil()
- command_util.sendCommand('OP_BROWSER_OPEN_URL', data)
+ command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
+ self._terminatedBrowser = False
+ self._enableKeyEvent = False
def _on_close_window(self):
self._onCloseTimer.start(1000)
- def _cmd_on_OpenLocation(self):
+ def _cb_bookmarkWindowClosed(self, data=None):
+ 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):
global _g_helper
if not _g_helper._is_browser_running():
- message = "Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu."
+ 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://')
+ 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)
+ 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()
- 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
- }
+ _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
+
+ def _cmd_on_Bookmark(self):
+ url = self._currentPageUrl
+ if url is None:
+ url = ''
+ title = self._currentPageTitle
+ if title is None:
+ title = ''
+ self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
+ def _cmd_on_Preference(self):
+ url = self._currentPageUrl
+ if url is None:
+ url = ''
+ self.session.open(OperaBrowserPreferenceWindow, url)
+ def _cmd_on_OpenStartpage(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
+ mode = 0
+ start = 'http://vuplus.com'
try:
- cmd_map[command]()
+ d = OperaBrowserSetting().getData()
+ start = d['start']
+ mode = d['type']
except: pass
+ self.cbUrlText(start, mode)
+ def _cmd_on_ReturnToBrowser(self):
+ self.keyCancel()
+
+ def _cmd_on_Help(self):
+ self.session.open(BrowserHelpWindow)
+
+ def doCommand(self, command):
+ try:
+ 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
@@ -985,8 +2074,8 @@ class OperaBrowser(Screen):
def updateSelectedMenuitem(self, status):
if self.menubarCurrentIndex == 0 and status < 0:
- self.menubarCurrentIndex = 1
- elif self.menubarCurrentIndex == 1 and status > 0:
+ self.menubarCurrentIndex = 2 # modify menu
+ elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
self.menubarCurrentIndex = 0
else: self.menubarCurrentIndex += status
self.selectMenuitem()
@@ -1001,8 +2090,11 @@ class OperaBrowser(Screen):
self.setCurrentListView(1)
self.toggleSubListView()
return
- if self.currentListView.getSelectedIndex():
- self.currentListView.pageUp()
+ #if self.currentListView.getSelectedIndex():
+ self.currentListView.pageUp()
+ self.keyUp()
+ self.keyLeft()
+ self.keyDown()
def keyRight(self):
if not self.toggleMainScreenFlag:
@@ -1019,6 +2111,11 @@ class OperaBrowser(Screen):
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()
+ return
+ self.currentListView.pageUp()
+ self.keyUp()
+ self.keyRight()
+ self.keyDown()
def keyDown(self):
if not self.toggleMainScreenFlag:
@@ -1045,19 +2142,101 @@ class OperaBrowser(Screen):
self.currentListView.up()
def keyCancel(self):
+ if not self._terminatedBrowser:
+ #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._currentPageTitle = None
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_MENU_RES')
+ return
+ self.close()
+
+ def keyMenu(self):
self.toggleMainScreen()
+ def setCurrentPageUrl(self, url, title=None):
+ self._currentPageUrl = url
+ if title is None:
+ idx = len(url)
+ if idx > 10: idx = 10
+ title = url[:idx]
+ self._currentPageTitle = title
+ print self._currentPageUrl
+ self.toggleMainScreen()
+ self.hideSubmenu()
+ self.keyDown()
+
+ def hideSubmenu(self):
+ self.currentListView.pageUp()
+ self.keyUp()
+
def auto_start_main(reason, **kwargs):
if reason:
command_server = getCommandServer()
command_server.stop()
+from Screens.HelpMenu import HelpableScreen
def session_start_main(session, reason, **kwargs):
+ fbClass.getInstance().unlock()
+ eRCInput.getInstance().unlock()
+
+ from enigma import getDesktop
+ desktopSize = getDesktop(0).size()
+ setDefaultResolution(desktopSize.width(), desktopSize.height())
+
global _g_helper
_g_helper = session.open(HbbTVHelper)
+ HelpableScreen.__init__ = HelpableScreen__init__
+ HelpableScreen.session = session
+
+def HelpableScreen__init__(self):
+ if isinstance(self, HelpableScreen):
+ HelpableScreen.showManual = showManual
+
+ self["helpActions"] = ActionMap(["HelpbuttonActions"], {
+ "help_b" : self.showHelp,
+ "help_l" : self.showManual,
+ }, -2)
+
+_g_clearBrowserDataTimer = eTimer()
+def showManual(self):
+ if not os.path.exists('/usr/local/manual'):
+ return
+
+ url = 'file:///usr/local/manual/main.html'
+ lang = language.getLanguage()
+ if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
+ url = 'file:///usr/local/manual/ru_RU/main.html'
+ elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
+ url = 'file:///usr/local/manual/de_DE/main.html'
+
+ def _do_clean():
+ _g_clearBrowserDataTimer.stop()
+ 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))
+
def plugin_start_main(session, **kwargs):
- session.open(OperaBrowser)
+ #session.open(OperaBrowser)
+ def _do_clean():
+ _g_clearBrowserDataTimer.stop()
+ try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
+ except: pass
+ setPluginBrowser(None)
+ def clearBrowserData():
+ _g_clearBrowserDataTimer.callback.append(_do_clean)
+ _g_clearBrowserDataTimer.start(50)
+ setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
def plugin_extension_start_application(session, **kwargs):
global _g_helper
@@ -1072,11 +2251,12 @@ def plugin_extension_browser_config(session, **kwargs):
_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)
- ]
+ 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=_("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))
+ l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))
+
+ return l