code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/Extensions/HbbTV/plugin.py

   1 from Plugins.Plugin import PluginDescriptor
   2
   3 from Screens.Screen import Screen
   4 from Screens.InfoBar import InfoBar
   5 from Screens.ChoiceBox import ChoiceBox
   6 from Screens.MessageBox import MessageBox
   7 from Screens.InfoBarGenerics import InfoBarNotifications
   8 from Screens.VirtualKeyBoard import VirtualKeyBoard
   9 from Screens.HelpMenu import HelpableScreen
  10 from Screens.ChannelSelection import service_types_tv
  11
  12 from Components.Language import language
  13 from Components.PluginComponent import plugins
  14 from Components.Button import Button
  15 from Components.Sources.StaticText import StaticText
  16 from Components.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
  17 from Components.ServiceEventTracker import ServiceEventTracker
  18 from Components.MenuList import MenuList
  19 from Components.Label import Label, MultiColorLabel
  20 from Components.ConfigList import ConfigListScreen
  21 from Components.VolumeControl import VolumeControl
  22 from Components.Pixmap import Pixmap
  23 from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue
  24
  25 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
  26
  27 from bookmark import BookmarkManager, BookmarkData, CategoryData
  28
  29 import os, struct, threading, stat, select, time, socket, select
  30
  31 from __init__ import _
  32
  33 strIsEmpty = lambda x: x is None or len(x) == 0
  34
  35 HBBTVAPP_PATH = "/usr/local/hbb-browser"
  36 COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
  37
  38 _g_helper = None
  39
  40 class GlobalValues:
  41         command_util   = None
  42         command_server = None
  43
  44         before_service = None
  45
  46         channel_info_sid   = None
  47         channel_info_onid  = None
  48         channel_info_tsid  = None
  49         channel_info_name  = None
  50         channel_info_orgid = None
  51
  52         hbbtv_handelr = None
  53
  54         packet_m  = 0xBBADBEE
  55         packet_h  = '!IIII'
  56         packet_hl = struct.calcsize(packet_h)
  57
  58         need_restart = False
  59         plugin_browser = None
  60
  61         resX = 0
  62         resY = 0
  63         def UpdateInfoBar(self):
  64                 if self.resX == 1024 and self.resY == 720:
  65                         return
  66                 try:
  67                         infobar = InfoBar.instance
  68                         if infobar._InfoBarShowHide__state != 3:
  69                                 return
  70                         infobar.doTimerHide()
  71                         infobar.serviceStarted()
  72                 except: pass
  73
  74 __gval__ = GlobalValues()
  75
  76 def setDefaultResolution(x, y):
  77         global __gval__
  78         __gval__.resX = x
  79         __gval__.resY = y
  80
  81 def setResolution(xres, yres):
  82         global __gval__
  83         if __gval__.resX == 1280 and __gval__.resY == 720:
  84                 return
  85         from enigma import gMainDC
  86         gMainDC.getInstance().setResolution(xres, yres)
  87
  88 def restoreResolution():
  89         global __gval__
  90         setResolution(1280, 720)
  91         setResolution(__gval__.resX, __gval__.resY)
  92
  93         if __gval__.resX == 1280 and __gval__.resY == 720:
  94                 return
  95         __gval__.UpdateInfoBar()
  96
  97 def setPluginBrowser(browser=None):
  98         global __gval__
  99         __gval__.plugin_browser = browser
 100 def getPluginBrowser():
 101         global __gval__
 102         return __gval__.plugin_browser
 103
 104 def getPacketHeaders():
 105         global __gval__
 106         return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
 107
 108 def setChannelInfo(sid, onid, tsid, name, orgid):
 109         if sid is None:   sid   = 0;
 110         if onid is None:  onid  = 0;
 111         if tsid is None:  tsid  = 0;
 112         if name is None:  name  = "";
 113         if orgid is None: orgid = 0;
 114         global __gval__
 115         __gval__.channel_info_sid   = sid
 116         __gval__.channel_info_onid  = onid
 117         __gval__.channel_info_tsid  = tsid
 118         __gval__.channel_info_name  = name
 119         __gval__.channel_info_orgid = orgid
 120         print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
 121 def getChannelInfos():
 122         global __gval__
 123         print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
 124                 __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
 125         return (__gval__.channel_info_sid,
 126                 __gval__.channel_info_onid,
 127                 __gval__.channel_info_tsid,
 128                 __gval__.channel_info_name,
 129                 __gval__.channel_info_orgid)
 130
 131 def isNeedRestart():
 132         global __gval__
 133         print "Need Restart(GET) : ", __gval__.need_restart
 134         return __gval__.need_restart
 135 def setNeedRestart(n):
 136         global __gval__
 137         __gval__.need_restart = n
 138         print "Need Restart(SET) : ", __gval__.need_restart
 139
 140 def getCommandUtil():
 141         global __gval__
 142         return __gval__.command_util
 143 def getCommandServer():
 144         global __gval__
 145         return __gval__.command_server
 146
 147 def setBeforeService(s):
 148         global __gval__
 149         __gval__.before_service = s
 150 def getBeforeService():
 151         global __gval__
 152         return __gval__.before_service
 153
 154 def _unpack(packed_data):
 155         (mg, h, hlen) = getPacketHeaders()
 156
 157         if strIsEmpty(packed_data):
 158                 return None
 159         (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
 160         if m != mg:
 161                 return None
 162         d = 0
 163         if l > 0:
 164                 d = packed_data[hlen:hlen+l]
 165         return (o,d,s)
 166
 167 def _pack(opcode, params=None, reserved=0):
 168         (m, h, hlen) = getPacketHeaders()
 169         if strIsEmpty(params):
 170                 params = ''
 171         packed_data = struct.pack(h, m, opcode, len(params), reserved)
 172         return packed_data + params
 173
 174 class MMSStreamURL:
 175         headers = [
 176                    'GET %s HTTP/1.0'
 177                   ,'Accept: */* '
 178                   ,'User-Agent: NSPlayer/7.10.0.3059 '
 179                   ,'Host: %s '
 180                   ,'Connection: Close '
 181                   ]
 182
 183         def __init__(self):
 184                 self.sendmsg = ''
 185                 for m in self.headers:
 186                         self.sendmsg += m + '\n'
 187                 self.sendmsg += '\n\n'
 188
 189         def request(self, host, port=80, location='/'):
 190                 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 191                 sock.connect((host, port))
 192                 sock.send(self.sendmsg%(location, host))
 193                 print "Request."
 194                 print self.sendmsg%(location, host)
 195                 fullydata = ''
 196                 while 1:
 197                         res = sock.recv(1024)
 198                         if res == '': break
 199                         fullydata += res
 200                 sock.close()
 201                 return fullydata
 202
 203         def parse(self, data):
 204                 for d in data.splitlines():
 205                         if d.startswith('Location: '):
 206                                 return d[9:]
 207                 return None
 208
 209         def getLocationData(self, url):
 210                 url_list,host,location = None,None,None
 211                 try:
 212                         url = url[url.find(':')+3:]
 213                         url_list = url.split('/')
 214                         host = url_list[0]
 215                         location = url[len(url_list[0]):]
 216                 except Exception, err_msg:
 217                         print err_msg
 218                         return None
 219                 html = self.request(host=host, location=location)
 220                 return self.parse(html)
 221
 222 class OpCodeSet:
 223         def __init__(self):
 224                 self._opcode_ = {
 225                          "OP_UNKNOWN"                   : 0x0000
 226                         ,"OP_HBBTV_EXIT"                : 0x0001
 227                         ,"OP_HBBTV_OPEN_URL"            : 0x0002
 228                         ,"OP_HBBTV_LOAD_AIT"            : 0x0003
 229                         ,"OP_HBBTV_UNLOAD_AIT"          : 0x0004
 230                         ,"OP_HBBTV_FULLSCREEN"          : 0x0005
 231                         ,"OP_HBBTV_TITLE"               : 0x0006
 232                         ,"OP_HBBTV_RETRY_OPEN_URL"      : 0x0009
 233                         ,"OP_HBBTV_CHANGE_CHANNEL"      : 0x000A
 234                         ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
 235                         ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
 236                         ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
 237                         ,"OP_VOD_URI"                   : 0x0201
 238                         ,"OP_VOD_PLAY"                  : 0x0202
 239                         ,"OP_VOD_STOP"                  : 0x0203
 240                         ,"OP_VOD_PAUSE"                 : 0x0204
 241                         ,"OP_VOD_STATUS"                : 0x0205
 242                         ,"OP_VOD_FORBIDDEN"             : 0x0206
 243                         ,"OP_VOD_STOPED"                : 0x0207
 244                         ,"OP_VOD_SPEED_CTRL"            : 0x0208
 245                         ,"OP_VOD_SEEK_CTRL"             : 0x0209
 246                         ,"OP_BROWSER_OPEN_URL"          : 0x0301
 247                         ,"OP_BROWSER_VKBD_REQ"          : 0x0309
 248                         ,"OP_BROWSER_VKBD_RES"          : 0x030A
 249                         ,"OP_BROWSER_VKBD_PASTE_REQ"    : 0x030B
 250                         ,"OP_BROWSER_VKBD_PASTE_KEY"    : 0x030C
 251                         ,"OP_BROWSER_VKBD_PASTE_MOUSE"  : 0x030D
 252                         ,"OP_BROWSER_MENU_REQ"          : 0x030E
 253                         ,"OP_BROWSER_MENU_RES"          : 0x030F
 254                         ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
 255                         ,"OP_DVBAPP_VOL_UP"             : 0x0401
 256                         ,"OP_DVBAPP_VOL_DOWN"           : 0x0402
 257                         ,"OP_SYSTEM_OUT_OF_MEMORY"      : 0x0501
 258                         ,"OP_SYSTEM_NOTIFY_MY_PID"      : 0x0502
 259                 }
 260                 self._opstr_ = {
 261                          0x0000 : "OP_UNKNOWN"
 262                         ,0x0001 : "OP_HBBTV_EXIT"
 263                         ,0x0002 : "OP_HBBTV_OPEN_URL"
 264                         ,0x0003 : "OP_HBBTV_LOAD_AIT"
 265                         ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
 266                         ,0x0005 : "OP_HBBTV_FULLSCREEN"
 267                         ,0x0006 : "OP_HBBTV_TITLE"
 268                         ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
 269                         ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
 270                         ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
 271                         ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
 272                         ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
 273                         ,0x0201 : "OP_VOD_URI"
 274                         ,0x0202 : "OP_VOD_PLAY"
 275                         ,0x0203 : "OP_VOD_STOP"
 276                         ,0x0204 : "OP_VOD_PAUSE"
 277                         ,0x0205 : "OP_VOD_STATUS"
 278                         ,0x0206 : "OP_VOD_FORBIDDEN"
 279                         ,0x0207 : "OP_VOD_STOPED"
 280                         ,0x0208 : "OP_VOD_SPEED_CTRL"
 281                         ,0x0209 : "OP_VOD_SEEK_CTRL"
 282                         ,0x0301 : "OP_BROWSER_OPEN_URL"
 283                         ,0x0309 : "OP_BROWSER_VKBD_REQ"
 284                         ,0x030A : "OP_BROWSER_VKBD_RES"
 285                         ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
 286                         ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
 287                         ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
 288                         ,0x030E : "OP_BROWSER_MENU_REQ"
 289                         ,0x030F : "OP_BROWSER_MENU_RES"
 290                         ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
 291                         ,0x0401 : "OP_DVBAPP_VOL_UP"
 292                         ,0x0402 : "OP_DVBAPP_VOL_DOWN"
 293                         ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
 294                         ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
 295                 }
 296
 297         def get(self, opstr):
 298                 try:
 299                         return self._opcode_[opstr]
 300                 except: pass
 301                 return self._opcode_["OP_UNKNOWN"]
 302
 303         def what(self, opcode):
 304                 try:
 305                         return self._opstr_[opcode]
 306                 except: pass
 307                 return self._opstr_["0x0000"]
 308
 309 class SocketParams:
 310         def __init__(self):
 311                 self.protocol = None
 312                 self.type     = None
 313                 self.addr     = None
 314                 self.buf_size = 4096
 315                 self.handler  = None
 316                 self.timeout  = 5
 317                 self.destroy  = None
 318
 319 class StreamServer:
 320         def __init__(self, params):
 321                 self._protocol = params.protocol
 322                 self._type     = params.type
 323                 self._addr     = params.addr
 324                 self._buf_size = params.buf_size
 325                 self._handler  = params.handler
 326                 self._timeout  = params.timeout
 327                 self._destroy  = params.destroy
 328
 329                 self._terminated = False
 330                 self._server_thread = None
 331
 332                 self.onHbbTVCloseCB = []
 333                 self.onSetPageTitleCB = []
 334
 335         def __del__(self):
 336                 if self._destroy is not None:
 337                         self._destroy(self._addr)
 338
 339         def stop(self):
 340                 self._terminated = True
 341                 if self._server_thread is not None:
 342                         self._server_thread.join()
 343                         self._server_thread = None
 344
 345         def start(self):
 346                 self._socket = socket.socket(self._protocol, self._type)
 347                 self._socket.settimeout(self._timeout)
 348                 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 349                 self._socket.bind(self._addr)
 350                 self._socket.listen(True)
 351
 352                 self._server_thread = threading.Thread(target=self._listen)
 353                 self._server_thread.start()
 354
 355         def _listen(self):
 356                 select_list = [self._socket]
 357                 def _accept():
 358                         try:
 359                                 conn, addr = self._socket.accept()
 360                                 self._client(conn, addr)
 361                         except Exception, ErrMsg:
 362                                 print "ServerSocket Error >>", ErrMsg
 363                                 pass
 364
 365                 while not self._terminated:
 366                         readable, writable, errored = select.select(select_list, [], [], self._timeout)
 367                         for s in readable:
 368                                 if s is self._socket:
 369                                         _accept()
 370
 371         def _client(self, conn, addr):
 372                 try:
 373                         send_data     = ''
 374                         received_data = conn.recv(self._buf_size)
 375                         if self._handler is not None and not strIsEmpty(received_data):
 376                                 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
 377                         self._send(conn, send_data)
 378                 except Exception, ErrMsg:
 379                         try: conn.close()
 380                         except:pass
 381                         if self._handler is not None:
 382                                 self._handler.printError(ErrMsg)
 383         def _send(self, conn, data) :
 384                 conn.send(data)
 385                 conn.close()
 386
 387 class ServerFactory:
 388         def doListenUnixTCP(self, name, handler):
 389                 def destroy(name):
 390                         import os
 391                         try:
 392                                 if os.path.exists(name):
 393                                         os.unlink(name)
 394                                         print "Removed ", name
 395                         except: pass
 396                 destroy(name)
 397
 398                 params = SocketParams()
 399                 params.protocol = socket.AF_UNIX
 400                 params.type     = socket.SOCK_STREAM
 401                 params.addr     = name
 402                 params.handler  = handler
 403                 params.destroy  = destroy
 404
 405                 streamServer = StreamServer(params)
 406                 streamServer.start()
 407                 return streamServer
 408
 409         def doListenInetTCP(self, ip, port, handler):
 410                 print "Not implemented yet!!"
 411         def doListenUnixDGRAM(self, name, handler):
 412                 print "Not implemented yet!!"
 413         def doListenInetDGRAM(self, ip, port, handler):
 414                 print "Not implemented yet!!"
 415
 416 class Handler:
 417         def doUnpack(self, data):
 418                 return _unpack(data)
 419
 420         def doPack(self, opcode, params, reserved=0):
 421                 return _pack(opcode, params, reserved)
 422
 423         def doHandle(self, data, onCloseCB):
 424                 opcode, params = 0x0, 'Invalid Request!!'
 425                 return _pack(opcode, params)
 426
 427         def printError(self, reason):
 428                 print reason
 429
 430 class BrowserCommandUtil(OpCodeSet):
 431         def __init__(self):
 432                 self._fd = None
 433                 OpCodeSet.__init__(self)
 434
 435         def isConnected(self):
 436                 if self._fd is None:
 437                         return False
 438                 return True
 439
 440         def doConnect(self, filename):
 441                 if not os.path.exists(filename):
 442                         print "File not exists :", filename
 443                         return False
 444                 try:
 445                         self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
 446                         if self._fd is None:
 447                                 print "Fail to open file :", filename
 448                                 return False
 449                 except Exception, ErrMsg:
 450                         print ErrMsg
 451                         self._fd = None
 452                         return False
 453                 return True
 454
 455         def doDisconnect(self):
 456                 if self._fd is None:
 457                         return
 458                 os.close(self._fd)
 459                 self._fd = None
 460
 461         def doSend(self, command, params=None, reserved=0):
 462                 if self._fd is None:
 463                         print "No found pipe!!"
 464                         return False
 465                 data = ''
 466                 try:
 467                         data = _pack(self.get(command), params, reserved)
 468                         if data is None:
 469                                 return False
 470                         os.write(self._fd, data)
 471                         print "Send OK!! :", command
 472                 except: return False
 473                 return True
 474
 475         def sendCommand(self, command, params=None, reserved=0):
 476                 if not self.isConnected():
 477                         global COMMAND_PATH
 478                         self.doConnect(COMMAND_PATH)
 479                 result = self.doSend(command, params, reserved)
 480                 self.doDisconnect()
 481                 return result
 482
 483 class HandlerHbbTV(Handler):
 484         _vod_service = None
 485         def __init__(self, session):
 486                 self._session = session
 487                 self.opcode = OpCodeSet()
 488                 self.handle_map = {
 489                          0x0001 : self._cb_handleCloseHbbTVBrowser
 490                         ,0x0006 : self._cb_handleSetPageTitle
 491                         ,0x0009 : self._cb_handleHbbTVRetryOpen
 492                         ,0x000A : self._cb_handleHbbTVChangeChannel
 493                         ,0x0101 : self._cb_handleGetChannelInfoForUrl
 494                         ,0x0102 : self._cb_handleGetChannelInfoForAIT
 495                         ,0x0103 : self._cb_handleGetChannelInfoList
 496                         ,0x0201 : self._cb_handleVODPlayerURI
 497                         ,0x0202 : self._cb_handleVODPlayerPlay
 498                         ,0x0203 : self._cb_handleVODPlayerStop
 499                         ,0x0204 : self._cb_handleVODPlayerPlayPause
 500                         ,0x0401 : self._cb_handleDVBAppVolUp
 501                         ,0x0402 : self._cb_handleDVBAppVolDown
 502                         ,0x0208 : self._cb_handleVODSpeedCtrl
 503                         ,0x0209 : self._cb_handleVODSeekCtrl
 504                         ,0x0501 : self._cb_handleSystemOutOfMemory
 505                         ,0x0502 : self._cb_handleSystemNotufyMyPID
 506                         ,0x0309 : self._cb_handleShowVirtualKeyboard
 507                         ,0x030B : self._cb_handlePasteVirtualKeyboard
 508                         ,0x030E : self._cb_handleBrowserMenuReq
 509                 }
 510                 self._on_close_cb = None
 511                 self._on_set_title_cb = None
 512
 513                 self._vod_uri = None
 514
 515                 self._retry_open_url = None
 516                 self._timer_retry_open = eTimer()
 517                 self._timer_paste_vkbd = eTimer()
 518                 self._curren_title = None
 519
 520         def _handle_dump(self, handle, opcode, data=None):
 521                 if True: return
 522                 print str(handle)
 523                 try:
 524                         print "    - opcode : ", self.opcode.what(opcode)
 525                 except: pass
 526                 print "    - data   : ", data
 527
 528         def doHandle(self, data, onCloseCB, onSetPageTitleCB):
 529                 opcode, params, reserved = None, None, 0
 530                 self._on_close_cb = onCloseCB
 531                 self._on_set_title_cb = onSetPageTitleCB
 532                 try:
 533                         datas  = self.doUnpack(data)
 534                 except Exception, ErrMsg:
 535                         print "Unpacking packet ERR :", ErrMsg
 536                         params = 'fail to unpack packet!!'
 537                         opcode = self.opcode.get("OP_UNKNOWN")
 538                         return self.doPack(opcode, params)
 539                 else:
 540                         opcode = datas[0]
 541                         params = datas[1]
 542                 self.opcode.what(opcode)
 543
 544                 try:
 545                         #print self.handle_map[opcode]
 546                         (reserved, params) = self.handle_map[opcode](opcode, params)
 547                 except Exception, ErrMsg:
 548                         print "Handling packet ERR :", ErrMsg
 549                         params = 'fail to handle packet!!'
 550                         opcode = self.opcode.get("OP_UNKNOWN")
 551                         return self.doPack(opcode, params)
 552                 self._on_close_cb = None
 553                 self._on_set_title_cb = None
 554                 return self.doPack(opcode, params, reserved)
 555
 556         def _cb_handleHbbTVChangeChannel(self, opcode, data):
 557                 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
 558                 global _g_helper
 559                 if _g_helper is None:
 560                         return (0, "NOK")
 561                 dataItems = data.split(":")
 562                 sid  = dataItems[0]
 563                 tsid = dataItems[1]
 564                 if not _g_helper.doChangeChannel(sid, tsid):
 565                         return (0, "NOK")
 566                 return (0, "OK")
 567
 568         def _cb_handleBrowserMenuReq(self, opcode, data):
 569                 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
 570                 restoreResolution()
 571                 fbClass.getInstance().unlock()
 572                 eRCInput.getInstance().unlock()
 573                 browser = getPluginBrowser()
 574                 if browser is not None:
 575                         browser.setCurrentPageUrl(data, self._curren_title)
 576                 return (0, "OK")
 577
 578         def _cb_handlePasteVirtualKeyboard(self, opcode, data):
 579                 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
 580                 def _cb_PasteRefocusVirtualKeyboard():
 581                         self._timer_paste_vkbd.stop()
 582                         command_util = getCommandUtil()
 583                         command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
 584                         try:
 585                                 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
 586                         except: pass
 587                 def _cb_PasteKeyVirtualKeyboard():
 588                         self._timer_paste_vkbd.stop()
 589                         command_util = getCommandUtil()
 590                         command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
 591                         try:
 592                                 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
 593                         except: pass
 594                         self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
 595                         self._timer_paste_vkbd.start(100)
 596                 def _cb_PasteMouseVirtualKeyboard():
 597                         self._timer_paste_vkbd.stop()
 598                         command_util = getCommandUtil()
 599                         command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
 600                         #time.sleep(1)
 601                         #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
 602                         try:
 603                                 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
 604                         except: pass
 605                         #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
 606                         #self._timer_paste_vkbd.start(1000)
 607                 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
 608                 self._timer_paste_vkbd.start(50)
 609                 return (0, "OK")
 610
 611         def _cb_virtualKeyboardClosed(self, data=None):
 612                 fbClass.getInstance().lock()
 613                 eRCInput.getInstance().lock()
 614                 setResolution(1280, 720)
 615                 command_util = getCommandUtil()
 616                 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
 617         def _cb_handleShowVirtualKeyboard(self, opcode, data):
 618                 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
 619                 restoreResolution()
 620                 fbClass.getInstance().unlock()
 621                 eRCInput.getInstance().unlock()
 622                 if data == 0 or strIsEmpty(data):
 623                         data = ""
 624                 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
 625                 return (0, "OK")
 626
 627         def _cb_handleVODSeekCtrl(self, opcode, data):
 628                 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
 629                 headLen = struct.calcsize('!I')
 630                 unpackedData = struct.unpack('!I', data[:headLen])
 631                 seekTime = unpackedData[0]
 632                 service = self._session.nav.getCurrentService()
 633                 seekable = service.seek()
 634                 if seekable is None or not seekable.isCurrentlySeekable():
 635                         raise Exception("This stream is not support manual seek.")
 636                 pts = seekTime
 637                 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
 638                 return (0, "OK")
 639
 640         def _cb_handleHbbTVRetryOpen(self, opcode, data):
 641                 def _cb_HbbTVRetryOpenURL():
 642                         self._timer_retry_open.stop()
 643                         if self._retry_open_url is not None:
 644                                 command_util = getCommandUtil()
 645                                 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
 646                         self._retry_open_url = None
 647                         try:
 648                                 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
 649                         except: pass
 650                 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
 651                 headLen = struct.calcsize('!I')
 652                 unpackedData = struct.unpack('!I', data[:headLen])
 653                 delayTime = unpackedData[0]
 654                 restartUrl = data[headLen:]
 655
 656                 self._retry_open_url = restartUrl.strip()
 657                 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
 658                 self._timer_retry_open.start(delayTime*1000)
 659                 return (0, "OK")
 660
 661         def _cb_handleSystemNotufyMyPID(self, opcode, data):
 662                 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
 663                 return (0, "OK")
 664
 665         def _cb_handleSystemOutOfMemory(self, opcode, data):
 666                 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
 667                 setNeedRestart(True)
 668                 return (0, "OK")
 669
 670         def _cb_handleVODSpeedCtrl(self, opcode, data):
 671                 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
 672                 headLen = struct.calcsize('!I')
 673                 unpackedData = struct.unpack('!I', data[:headLen])
 674                 playSpeed = unpackedData[0]
 675                 service = self._session.nav.getCurrentService()
 676                 pauseable = service.pause()
 677                 if playSpeed > 2:
 678                         playSpeed = 2
 679                 if pauseable.setFastForward(playSpeed) == -1:
 680                         pauseable.setFastForward(1)
 681                         raise Exception("This stream is not support trick play.")
 682                 return (0, "OK")
 683
 684         def _cb_handleDVBAppVolUp(self, opcode, data):
 685                 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
 686                 vcm = VolumeControl.instance
 687                 vcm.volUp()
 688                 return (0, "OK")
 689
 690         def _cb_handleDVBAppVolDown(self, opcode, data):
 691                 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
 692                 vcm = VolumeControl.instance
 693                 vcm.volDown()
 694                 return (0, "OK")
 695
 696         def _cb_handleGetChannelInfoForUrl(self, opcode, data):
 697                 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
 698                 (sid, onid, tsid, name, orgid) = getChannelInfos()
 699                 namelen = len(name)
 700                 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
 701
 702         def _cb_handleGetChannelInfoForAIT(self, opcode, data):
 703                 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
 704                 (sid, onid, tsid, name, orgid) = getChannelInfos()
 705                 namelen = len(name)
 706                 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
 707
 708         def _cb_handleGetChannelInfoList(self, opcode, data):
 709                 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
 710                 (sid, onid, tsid, name, orgid) = getChannelInfos()
 711                 namelen = len(name)
 712                 channel_list_size = 1
 713                 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
 714
 715         def _cb_handleSetPageTitle(self, opcode, data):
 716                 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
 717                 if data.startswith('file://') or data.startswith('http://'):
 718                         return "OK"
 719                 if self._on_set_title_cb is not None:
 720                         for x in self._on_set_title_cb:
 721                                 try:
 722                                         x(data)
 723                                         self._curren_title = data
 724                                 except Exception, ErrMsg:
 725                                         if x in self._on_set_title_cb:
 726                                                 self._on_set_title_cb.remove(x)
 727                 return (0, "OK")
 728
 729         def _cb_handleCloseHbbTVBrowser(self, opcode, data):
 730                 self._timer_retry_open.stop()
 731                 try:
 732                         self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
 733                 except: pass
 734                 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
 735
 736                 if self._on_close_cb:
 737                         for x in self._on_close_cb:
 738                                 try:
 739                                         x()
 740                                 except Exception, ErrMsg:
 741                                         if x in self._on_close_cb:
 742                                                 self._on_close_cb.remove(x)
 743
 744                 command_util = getCommandUtil()
 745                 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
 746
 747                 before_service = getBeforeService()
 748                 if before_service is not None:
 749                         self._session.nav.playService(before_service)
 750                         self._vod_uri = None
 751
 752                 restoreResolution()
 753                 return (0, "OK")
 754
 755         def _cb_handleVODPlayerURI(self, opcode, data):
 756                 self._vod_uri = None
 757                 hl = struct.calcsize('!II')
 758                 datas = struct.unpack('!II', data[:hl])
 759                 uriLength = datas[1]
 760                 vodUri = data[hl:hl+uriLength]
 761                 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
 762                 self._vod_uri = vodUri
 763                 return (0, "OK")
 764
 765         def doStop(self, restoreBeforeService=True, needStop=True):
 766                 if needStop == True:
 767                         self._session.nav.stopService()
 768                 if self._vod_service is not None and restoreBeforeService:
 769                         before_service = getBeforeService()
 770                         self._session.nav.playService(before_service)
 771                         self._vod_uri = None
 772                 self._vod_service = None
 773
 774         def getUrl(self):
 775                 return self._vod_uri
 776
 777         def doRetryOpen(self, url):
 778                 if url is None:
 779                         return False
 780                 for ii in range(5):
 781                         self._vod_service = None
 782                         try:
 783                                 print "Try to open vod [%d] : %s" % (ii, url)
 784                                 self._vod_service = eServiceReference(4097, 0, url)
 785                                 self._session.nav.playService(self._vod_service)
 786                                 if self._vod_service is not None:
 787                                         return True
 788                         except Exception, ErrMsg:
 789                                 print "OpenVOD ERR :", ErrMsg
 790                         time.sleep(1)
 791                 return False
 792
 793         def _cb_handleVODPlayerPlay(self, opcode, data):
 794                 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
 795                 self.doStop(restoreBeforeService=False)
 796                 if self.doRetryOpen(url=self._vod_uri) == False:
 797                         self.doStop()
 798                 return (0, "OK")
 799
 800         def _cb_handleVODPlayerStop(self, opcode, data):
 801                 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
 802                 self.doStop()
 803                 return (0, "OK")
 804
 805         def _cb_handleVODPlayerPlayPause(self, opcode, data):
 806                 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
 807                 service = self._session.nav.getCurrentService()
 808                 try:
 809                         pauseFlag = data[0]
 810                         servicePause = service.pause()
 811                         if pauseFlag == 'U':
 812                                 servicePause.unpause()
 813                         elif pauseFlag == 'P':
 814                                 servicePause.pause()
 815                 except Exception, ErrMsg:
 816                         print "onPause ERR :", ErrMsg
 817                 return (0, "OK")
 818
 819 from libshm import SimpleSharedMemory
 820 _g_ssm_ = None
 821 class HbbTVWindow(Screen, InfoBarNotifications):
 822         skin =  """
 823                 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
 824                 </screen>
 825                 """
 826         def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
 827                 self._session = session
 828                 setResolution(1280, 720)
 829                 fbClass.getInstance().lock()
 830                 eRCInput.getInstance().lock()
 831
 832                 Screen.__init__(self, session)
 833                 InfoBarNotifications.__init__(self)
 834                 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
 835                         iPlayableService.evUser+20: self._serviceForbiden,
 836                         iPlayableService.evStart: self._serviceStarted,
 837                         iPlayableService.evEOF: self._serviceEOF,
 838                 })
 839
 840                 self._url = url
 841                 self._use_ait = useAIT
 842                 self._profile = profile
 843                 self._cb_closed_func = cbf
 844                 self.onLayoutFinish.append(self._layoutFinished)
 845
 846                 command_server = getCommandServer()
 847                 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
 848                         command_server.onSetPageTitleCB.append(self._cb_set_page_title)
 849
 850                 if self._cb_close_window not in command_server.onHbbTVCloseCB:
 851                         command_server.onHbbTVCloseCB.append(self._cb_close_window)
 852
 853                 self._closeTimer = eTimer()
 854                 self._closeTimer.callback.append(self._do_close)
 855
 856                 self._currentServicePositionTimer = eTimer()
 857                 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
 858                 self._vodLength = 0
 859
 860                 global _g_ssm_
 861                 self._ssm = _g_ssm_
 862                 self._vod_length = 0
 863
 864         def getVodPlayTime(self):
 865                 try:
 866                         service = self._session.nav.getCurrentService()
 867                         seek = service and service.seek()
 868                         l = seek.getLength()
 869                         p = seek.getPlayPosition()
 870                         #return (p[1]/90000, l[1]/90000)
 871                         return (p[1], l[1])
 872                 except: pass
 873                 return (-1,-1)
 874
 875         def _cb_currentServicePosition(self):
 876                 def getTimeString(t):
 877                         t = time.localtime(t/90000)
 878                         return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
 879                 position,length = 0,0
 880                 try:
 881                         (position,length) = self.getVodPlayTime()
 882                         self._vod_length = length
 883                         if position == -1 and length == -1:
 884                                 raise Exception("Can't get play status")
 885                         #print getTimeString(position), "/", getTimeString(length)
 886                         self._ssm.setStatus(position, length, 1)
 887                 except Exception, ErrMsg:
 888                         print ErrMsg
 889                         self._serviceEOF()
 890
 891         def _serviceStarted(self):
 892                 try:
 893                         self._ssm.setStatus(0, 0, 0)
 894                         self._currentServicePositionTimer.start(1000)
 895                 except Exception, ErrMsg:
 896                         print ErrMsg
 897
 898         def _serviceEOF(self):
 899                 (position,length) = self.getVodPlayTime()
 900                 self._ssm.setStatus(length, length, 1)
 901                 print "service EOF"
 902                 self._currentServicePositionTimer.stop()
 903
 904         def _layoutFinished(self):
 905                 self.setTitle(_('HbbTV Plugin'))
 906                 command_util = getCommandUtil()
 907                 profile = self._profile
 908                 (sid, onid, tsid, name, orgid) = getChannelInfos()
 909                 params  = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
 910                 if self._use_ait:
 911                         command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
 912                         time.sleep(1)
 913                         command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
 914                         return
 915                 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
 916                 time.sleep(1)
 917                 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
 918
 919         def _cb_close_window(self):
 920                 self._closeTimer.start(1000)
 921
 922         def _do_close(self):
 923                 self._closeTimer.stop()
 924                 command_server = getCommandServer()
 925                 try:
 926                         if self._cb_set_page_title in command_server.onSetPageTitleCB:
 927                                 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
 928                 except Exception, ErrMsg: pass
 929                 try:
 930                         if self._cb_close_window in command_server.onHbbTVCloseCB:
 931                                         command_server.onHbbTVCloseCB.remove(self._cb_close_window)
 932                 except Exception, ErrMsg: pass
 933                 try:
 934                         if self._cb_closed_func is not None:
 935                                 self._cb_closed_func()
 936                 except: pass
 937                 restoreResolution()
 938                 fbClass.getInstance().unlock()
 939                 eRCInput.getInstance().unlock()
 940                 self.close()
 941
 942         def _serviceForbiden(self):
 943                 global __gval__
 944                 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
 945                 print "Received URI :\n", real_url
 946
 947                 if real_url is not None:
 948                         __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
 949
 950         def _cb_set_page_title(self, title=None):
 951                 print "page title :",title
 952                 if title is None:
 953                         return
 954                 self.setTitle(title)
 955
 956 class HbbTVHelper(Screen):
 957         skin =  """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
 958         def __init__(self, session):
 959                 global __gval__
 960                 __gval__.hbbtv_handelr = HandlerHbbTV(session)
 961                 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
 962
 963                 self._urls = None
 964
 965                 Screen.__init__(self, session)
 966                 self._session = session
 967
 968                 self._restart_opera()
 969
 970                 self._timer_infobar = eTimer()
 971                 self._timer_infobar.callback.append(self._cb_registrate_infobar)
 972                 self._timer_infobar.start(1000)
 973
 974                 self._excuted_browser = False
 975                 self._profile = 0
 976
 977                 __gval__.command_util = BrowserCommandUtil()
 978
 979                 global _g_ssm_
 980                 if _g_ssm_ is None:
 981                         _g_ssm_ = SimpleSharedMemory()
 982                         _g_ssm_.doConnect()
 983
 984                 self._callbackStartStop = None
 985
 986         def _cb_registrate_infobar(self):
 987                 if InfoBar.instance:
 988                         self._timer_infobar.stop()
 989                         if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
 990                                 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
 991                         if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
 992                                 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
 993
 994         def _cb_ready_for_ait(self, orgId=0):
 995                 if orgId == 0:
 996                         if not self._excuted_browser:
 997                                 command_util = getCommandUtil()
 998                                 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
 999                         return
1000                 setChannelInfo(None, None, None, None, None)
1001
1002                 service = self._session.nav.getCurrentService()
1003                 info = service and service.info()
1004                 if info is not None:
1005                         sid  = info.getInfo(iServiceInformation.sSID)
1006                         onid = info.getInfo(iServiceInformation.sONID)
1007                         tsid = info.getInfo(iServiceInformation.sTSID)
1008                         name = info.getName()
1009                         if name is None:
1010                                 name = ""
1011                         orgid   = 0
1012                         namelen = len(name)
1013                         for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
1014                                 if x[0] in (1, -1) :
1015                                         orgid = x[3]
1016                                         break
1017                         setChannelInfo(sid, onid, tsid, name, orgid)
1018
1019         def _cb_hbbtv_activated(self, title=None, url=None):
1020                 if not self._is_browser_running():
1021                         message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1022                         self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1023                         return
1024                 service = self._session.nav.getCurrentlyPlayingServiceReference()
1025                 setBeforeService(service)
1026                 self._start_hbbtv_application(title, url)
1027
1028         def _start_hbbtv_application(self, title, url):
1029                 use_ait = False
1030                 tmp_url = self.getStartHbbTVUrl()
1031                 if url is None:
1032                         url = tmp_url
1033                 if strIsEmpty(url):
1034                         print "can't get url of hbbtv!!"
1035                         return
1036                 print "success to get url of hbbtv!! >>", url
1037                 if self._excuted_browser:
1038                         print "already excuted opera browser!!"
1039                         return
1040
1041                 if isNeedRestart():
1042                         self._restart_opera()
1043                         time.sleep(2)
1044                         setNeedRestart(False)
1045
1046                 for x in self._urls:
1047                         control_code = x[0]
1048                         tmp_url = x[2]
1049                         if tmp_url == url and control_code == 1:
1050                                 use_ait = True
1051                 self._excuted_browser = True
1052                 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1053
1054         def _cb_closed_browser(self):
1055                 self._excuted_browser = False
1056
1057         def _start_opera(self):
1058                 if not self._is_browser_running():
1059                         global HBBTVAPP_PATH
1060                         start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1061                         os.system(start_command)
1062                 return True
1063
1064         def _stop_opera(self):
1065                 global HBBTVAPP_PATH
1066                 try:    os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1067                 except: pass
1068
1069         def _restart_opera(self):
1070                 global HBBTVAPP_PATH
1071                 try:    os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1072                 except: pass
1073                 return True
1074
1075         def getStartHbbTVUrl(self):
1076                 url, self._urls, self._profile = None, None, 0
1077                 service = self._session.nav.getCurrentService()
1078                 info = service and service.info()
1079                 if not info: return None
1080                 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1081                 for u in self._urls:
1082                         if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1083                                 url = u[2]
1084                                 self._profile = u[5]
1085                 if url is None:
1086                         url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1087                 return url
1088
1089         def showApplicationSelectionBox(self):
1090                 applications = []
1091
1092                 if self.getStartHbbTVUrl():
1093                         for x in self._urls:
1094                                 applications.append((x[1], x))
1095                 else: applications.append((_("No detected HbbTV applications."), None))
1096                 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1097
1098         def _application_selected(self, selected):
1099                 try:
1100                         if selected[1] is None: return
1101                         self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1102                 except Exception, ErrMsg: print ErrMsg
1103
1104         def showBrowserConfigBox(self, callback=None):
1105                 start_stop_mode = []
1106                 self._callbackStartStop = callback
1107                 if self._is_browser_running():
1108                         start_stop_mode.append((_('Stop'),'Stop'))
1109                 else:   start_stop_mode.append((_('Start'),'Start'))
1110                 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1111
1112         def _browser_config_selected(self, selected):
1113                 if selected is None:
1114                         return
1115                 if self._callbackStartStop is not None:
1116                         self._callbackStartStop()
1117                 try:
1118                         mode = selected[1]
1119                         if mode == 'Start':
1120                                 if not self._is_browser_running():
1121                                         self._start_opera()
1122                         elif mode == 'Stop':
1123                                 self._stop_opera()
1124                 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1125
1126         def _is_browser_running(self):
1127                 try:
1128                         global HBBTVAPP_PATH
1129                         ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1130                         return ret.strip() != "0"
1131                 except Exception, ErrMsg:
1132                         print "Check Browser Running ERR :", ErrMsg
1133                 return False
1134
1135         def doChangeChannel(self, _sid, _tsid):
1136                 root = eServiceReference(service_types_tv)
1137                 if root is None:
1138                         return False
1139                 serviceList = eServiceCenter.getInstance().list(root)
1140                 if serviceList is None:
1141                         return False
1142                 while True:
1143                         service = serviceList.getNext()
1144                         if service is None or not service.valid():
1145                                 break
1146
1147                         #1:0:19:2840:3FB:1:C00000:0:0:0:
1148                         serviceRef = service.toString()
1149                         if strIsEmpty(serviceRef):
1150                                 continue
1151                         serviceRefItems = serviceRef.split(":")
1152                         if len(serviceRefItems) < 5:
1153                                 continue
1154
1155                         sid  = serviceRefItems[3]
1156                         tsid = serviceRefItems[4]
1157                         if sid == _sid and tsid == _tsid:
1158                                 self._session.nav.playService(eServiceReference(serviceRef))
1159                                 service = self._session.nav.getCurrentlyPlayingServiceReference()
1160                                 setBeforeService(service)
1161                                 return True
1162                 return False
1163
1164 class OperaBrowserSetting:
1165         def __init__(self):
1166                 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1167                 self._start = None
1168                 self._type  = None
1169                 self._keymap = None
1170                 self._read()
1171         def _read(self):
1172                 f = open(self._settingFileName)
1173                 for line in f.readlines():
1174                         if line.startswith('start='):
1175                                 tmp = line[6:len(line)-1].split()
1176                                 self._start = tmp[0]
1177                                 if len(tmp) > 1:
1178                                         self._type = int(tmp[1])
1179                                 else:   self._type = 0
1180                         elif line.startswith('keymap='):
1181                                 self._keymap = line[7:len(line)-1]
1182                 f.close()
1183         def _write(self):
1184                 tmpstr = []
1185                 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1186                 tmpstr.append('keymap=%s\n' % (self._keymap))
1187                 f = open(self._settingFileName, 'w')
1188                 f.writelines(tmpstr)
1189                 f.close()
1190         def setData(self, start, types=0, keymap="us-rc"):
1191                 self._start = start
1192                 self._type = types
1193                 self._keymap = keymap
1194                 self._write()
1195         def getData(self):
1196                 return {
1197                         'start':self._start,
1198                         'type':self._type,
1199                         'keymap':self._keymap,
1200                 }
1201
1202 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1203         skin=   """
1204                 <screen position="center,120" size="600,350" title="Preference">
1205                         <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1206                         <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1207
1208                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1209                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1210
1211                         <widget source="key_red" render="Label" position="310,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1212                         <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" />
1213                 </screen>
1214                 """
1215         def __init__(self, session, currentUrl):
1216                 self.session = session
1217                 Screen.__init__(self, session)
1218
1219                 self.menulist = []
1220                 ConfigListScreen.__init__(self, self.menulist)
1221
1222                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1223                         "red"    : self.keyRed,
1224                         "green"  : self.keyGreen,
1225                         "ok"     : self.keyOK,
1226                         "cancel" : self.keyRed
1227                 }, -2)
1228                 self["key_red"]   = StaticText(_("Cancel"))
1229                 self["key_green"] = StaticText(_("Save"))
1230                 self["url"]       = Label()
1231
1232                 self._currentPageUrl = currentUrl
1233                 if self._currentPageUrl is None:
1234                         self._currentPageUrl = ''
1235                 self._startPageUrl   = None
1236                 self._keymapType = None
1237                 self.makeMenuEntry()
1238                 self.onLayoutFinish.append(self.layoutFinished)
1239
1240         def layoutFinished(self):
1241                 self.setTitle(_('Preference'))
1242
1243         def updateStartPageUrl(self):
1244                 if self.menuItemStartpage.value == "startpage":
1245                         self["url"].setText(self._startPageUrl)
1246                 elif self.menuItemStartpage.value == "current":
1247                         self["url"].setText(self._currentPageUrl)
1248                 elif self.menuItemStartpage.value == "direct":
1249                         self["url"].setText('')
1250
1251         def keyGreen(self):
1252                 url = self["url"].getText()
1253                 if strIsEmpty(url):
1254                         self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1255                         return
1256                 mode = 0
1257                 if url.find('/usr/local/manual') > 0:
1258                         mode = 1
1259                 self._keymapType = self.menuItemKeyboardLayout.value
1260                 OperaBrowserSetting().setData(url, mode, self._keymapType)
1261                 command_util = getCommandUtil()
1262                 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1263                 self.close()
1264
1265         def keyRed(self):
1266                 self.close()
1267
1268         def keyOK(self):
1269                 def _cb_directInputUrl(data):
1270                         if strIsEmpty(data):
1271                                 return
1272                         self["url"].setText(data)
1273                 if self.menuItemStartpage.value == "direct":
1274                         self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1275
1276         def keyLeft(self):
1277                 ConfigListScreen.keyLeft(self)
1278                 self.updateStartPageUrl()
1279
1280         def keyRight(self):
1281                 ConfigListScreen.keyRight(self)
1282                 self.updateStartPageUrl()
1283
1284         def getKeymapTypeList(self):
1285                 types = []
1286                 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1287                         filesplit = f.split('.')
1288                         if len(filesplit) < 2:
1289                                 continue
1290                         types.append((filesplit[1], filesplit[1]))
1291                 types.sort()
1292                 return types
1293
1294         def makeMenuEntry(self):
1295                 l = []
1296                 l.append(("startpage", _("Start Page")))
1297                 if not strIsEmpty(self._currentPageUrl):
1298                         l.append(("current", _("Current Page")))
1299                 l.append(("direct", _("Direct Input")))
1300                 self.menuItemStartpage  = ConfigSelection(default="startpage", choices = l)
1301                 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1302
1303                 kl = self.getKeymapTypeList()
1304
1305                 try:
1306                         d = OperaBrowserSetting().getData()
1307                         self._startPageUrl = d['start']
1308                         self._keymapType = d['keymap']
1309                         #d['type']
1310                 except: self._startPageUrl = 'http://vuplus.com'
1311                 self.updateStartPageUrl()
1312
1313                 if self._keymapType is None or len(self._keymapType) == 0:
1314                         self._keymapType = "us-rc"
1315                 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1316                 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1317                 self.resetMenuList()
1318
1319         def resetMenuList(self):
1320                 self.menulist = []
1321                 self.menulist.append(self.menuEntryStartpage)
1322                 self.menulist.append(self.menuEntryKeyboardLayout)
1323
1324                 self["config"].list = self.menulist
1325                 self["config"].l.setList(self.menulist)
1326
1327 class BookmarkEditWindow(ConfigListScreen, Screen):
1328         CATEGORY,BOOKMARK = 0,1
1329         skin=   """
1330                 <screen position="center,center" size="600,140" title="Bookmark Edit">
1331                         <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1332
1333                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1334                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1335
1336                         <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" />
1337                         <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" />
1338
1339                         <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1340
1341                 </screen>
1342                 """
1343         def __init__(self, session, _mode, _type, _data, _bm):
1344                 self.mMode = _mode
1345                 self.mType = _type
1346                 self.mData = _data
1347                 self.mSession = session
1348                 self.mBookmarkManager = _bm
1349
1350                 if _data is not None:
1351                         print _data.mId
1352
1353                 Screen.__init__(self, session)
1354
1355                 self.menulist = []
1356                 ConfigListScreen.__init__(self, self.menulist)
1357
1358                 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1359                         "ok"     : self.keyGreen,
1360                         "green"  : self.keyGreen,
1361                         "red"    : self.keyRed,
1362                         "cancel" : self.keyRed,
1363                 }, -2)
1364
1365                 self["VKeyIcon"]  = Pixmap()
1366                 self["key_red"]   = StaticText(_("Cancel"))
1367                 self["key_green"] = StaticText(_("Save"))
1368
1369                 self.menuItemTitle = None
1370                 self.menuItemUrl   = None
1371                 self.menuItemName  = None
1372
1373                 self.menuEntryName = None
1374                 self.menuEntryTitle = None
1375                 self.menuEntryUrl = None
1376
1377                 self.makeConfigList()
1378                 self.onLayoutFinish.append(self.layoutFinished)
1379
1380         def layoutFinished(self):
1381                 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1382
1383         def selectedItem(self):
1384                 currentPosition = self["config"].getCurrent()
1385                 if self.mType == BookmarkEditWindow.CATEGORY:
1386                         return (_("Name"), self.menuItemName)
1387                 else:
1388                         if currentPosition == self.menuEntryTitle:
1389                                 return (_("Title"), self.menuItemTitle)
1390                         elif currentPosition == self.menuEntryUrl:
1391                                 return (_("Url"), self.menuItemUrl)
1392                 return None
1393
1394         def showMessageBox(self, text):
1395                 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1396                 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1397                 return False
1398
1399         def showVKeyWindow(self, data=None):
1400                 itemTitle = ""
1401                 itemValue = ""
1402                 selected = self.selectedItem()
1403                 if selected is not None:
1404                         itemValue = selected[1].value
1405                         if strIsEmpty(itemValue):
1406                                 itemValue = ""
1407                         itemTitle = selected[0]
1408
1409                 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1410
1411         def cbVKeyWindow(self, data=None):
1412                 if data is not None:
1413                         selected = self.selectedItem()
1414                         if selected is not None:
1415                                 selected[1].setValue(data)
1416
1417         def saveData(self):
1418                 if self.mType == BookmarkEditWindow.CATEGORY:
1419                         if self.mMode == _('Add'):
1420                                 categoryName = self.menuItemName.value
1421                                 if strIsEmpty(categoryName):
1422                                         return self.showMessageBox(_("Category Name"))
1423                                 self.mBookmarkManager.addCategory(categoryName)
1424                         else:
1425                                 if strIsEmpty(self.menuItemName.value):
1426                                         return self.showMessageBox(_("Category Name"))
1427                                 self.mData.mName = self.menuItemName.value
1428                                 self.mBookmarkManager.updateCategory(self.mData)
1429                 else:
1430                         if self.mMode == _('Add'):
1431                                 bookmarkTitle = self.menuItemTitle.value
1432                                 bookmarkUrl   = self.menuItemUrl.value
1433                                 if strIsEmpty(bookmarkTitle):
1434                                         self["config"].setCurrentIndex(0)
1435                                         return self.showMessageBox(_("Bookmark Title"))
1436                                 if strIsEmpty(bookmarkUrl):
1437                                         self["config"].setCurrentIndex(1)
1438                                         return self.showMessageBox(_("Bookmark URL"))
1439                                 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1440                         else:
1441                                 if strIsEmpty(self.menuItemTitle.value):
1442                                         self["config"].setCurrentIndex(0)
1443                                         return self.showMessageBox(_("Bookmark Title"))
1444                                 if strIsEmpty(self.menuItemUrl.value):
1445                                         self["config"].setCurrentIndex(1)
1446                                         return self.showMessageBox(_("Bookmark URL"))
1447                                 self.mData.mTitle = self.menuItemTitle.value
1448                                 self.mData.mUrl   = self.menuItemUrl.value
1449                                 self.mBookmarkManager.updateBookmark(self.mData)
1450                 return True
1451
1452         def keyGreen(self):
1453                 if not self.saveData():
1454                         return
1455                 self.close(True)
1456         def keyRed(self):
1457                 self.close(False)
1458         def keyLeft(self):
1459                 ConfigListScreen.keyLeft(self)
1460         def keyRight(self):
1461                 ConfigListScreen.keyRight(self)
1462         def makeConfigList(self):
1463                 self.menulist = []
1464
1465                 if self.mType == BookmarkEditWindow.CATEGORY:
1466                         self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1467
1468                         self.menuEntryName  = getConfigListEntry(_("Name"), self.menuItemName)
1469
1470                         self.menulist.append(self.menuEntryName)
1471                 else:
1472                         self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1473                         self.menuItemUrl   = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1474
1475                         self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1476                         self.menuEntryUrl   = getConfigListEntry(_("Url"), self.menuItemUrl)
1477
1478                         self.menulist.append(self.menuEntryTitle)
1479                         self.menulist.append(self.menuEntryUrl)
1480
1481                 self["config"].list = self.menulist
1482                 self["config"].l.setList(self.menulist)
1483
1484 class OperaBrowserBookmarkWindow(Screen):
1485         skin =  """
1486                 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1487                         <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1488
1489                         <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1490                         <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1491
1492                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1493                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1494                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1495                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1496
1497                         <widget source="key_red" render="Label" position="5,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1498                         <widget source="key_green" render="Label" position="155,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1499                         <widget source="key_yellow" render="Label" position="305,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
1500                         <widget source="key_blue" render="Label" position="450,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
1501                 </screen>
1502                 """
1503
1504         def __init__(self, _session, _url=None, _title=None):
1505                 self.mUrl   = _url
1506                 self.mTitle = _title
1507                 self.mBookmarkManager = BookmarkManager.getInstance()
1508                 self.mSession = _session
1509                 Screen.__init__(self, _session)
1510                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1511                                 "ok"    : self.keyOK,
1512                                 "cancel": self.keyCancel,
1513                                 "red"   : self.keyRed,
1514                                 "green" : self.keyGreen,
1515                                 "yellow": self.keyYellow,
1516                                 "blue"  : self.keyBlue,
1517                                 "0"     : self.keyNumber,
1518                         },-2)
1519
1520                 self["key_red"]    = StaticText(_("Exit"))
1521                 self["key_green"]  = StaticText(_("Add"))
1522                 self["key_yellow"] = StaticText(_("Edit"))
1523                 self["key_blue"]   = StaticText(_("Delete"))
1524                 self["key_0"]      = StaticText(_("Set as Startpage"))
1525
1526                 self.mBookmarkList = self.setBookmarkList()
1527                 self["bookmarklist"] = MenuList(self.mBookmarkList)
1528
1529                 self.onLayoutFinish.append(self.layoutFinished)
1530
1531         def layoutFinished(self):
1532                 self.setTitle(_('Bookmark'))
1533
1534         def setBookmarkList(self):
1535                 l = []
1536                 #self.mBookmarkManager.dump()
1537                 cd = self.mBookmarkManager.getBookmarkRoot()
1538                 for ck in cd.iterkeys():
1539                         l.append(('# ' + cd[ck].mName, cd[ck]))
1540                         bd = cd[ck].mBookmarks
1541                         for bk in bd.iterkeys():
1542                                 l.append(('    - ' + bd[bk].mTitle, bd[bk]))
1543                 return l
1544         def updateBookmarkList(self):
1545                 self.mBookmarkList = self.setBookmarkList()
1546                 self["bookmarklist"].setList(self.mBookmarkList)
1547         def cbEditWindow(self, ret=False):
1548                 if not ret:
1549                         return
1550                 self.updateBookmarkList()
1551         def getParentCategory(self):
1552                 idx = self["bookmarklist"].getSelectedIndex()
1553                 try:
1554                         while idx >= 0:
1555                                 data = self.mBookmarkList[idx][0].strip()
1556                                 if data[0] == '#':
1557                                         return self.mBookmarkList[idx][1]
1558                                 idx -= 1
1559                 except: pass
1560                 return None
1561         def isCategoryItem(self):
1562                 try:
1563                         head = self["bookmarklist"].getCurrent()[0].strip()
1564                         if head[0] == '#':
1565                                 return True
1566                 except: pass
1567                 return False
1568         def keyNumber(self):
1569                 data = self["bookmarklist"].getCurrent()[1]
1570                 if strIsEmpty(data.mUrl):
1571                         msg = _("Invalid URL. Please check again!!")
1572                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1573                         return
1574                 def cbSetStartpage(ret=None):
1575                         if ret is None: return
1576                         if ret:
1577                                 data = self["bookmarklist"].getCurrent()[1]
1578                                 OperaBrowserSetting().setData(data.mUrl, data.mType)
1579                 msg = _("Do you want to set selected url to the Startpage?")
1580                 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1581
1582         def keyGreen(self):
1583                 def cbGreen(data):
1584                         if data is None:
1585                                 return
1586                         if data[1] == 1:
1587                                 parent = self.getParentCategory()
1588                                 if parent is None:
1589                                         return
1590                                 if strIsEmpty(self.mTitle):
1591                                         return
1592                                 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1593                                 if not retAdd:
1594                                         msg = _("Current page is already exist.")
1595                                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1596                                 self.cbEditWindow(True)
1597                         elif data[1] == 2:
1598                                 parent = self.getParentCategory()
1599                                 if parent is None:
1600                                         return
1601                                 b = BookmarkData(0, '', '', parent.mId, 0)
1602                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1603                         elif data[1] == 3:
1604                                 c = CategoryData(0, '')
1605                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1606                 if strIsEmpty(self.mUrl):
1607                         l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1608                 else:   l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1609                 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1610         def keyYellow(self):
1611                 data = self["bookmarklist"].getCurrent()[1]
1612                 if self.isCategoryItem():
1613                         self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1614                 else:   self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1615         def keyBlue(self):
1616                 def cbBlue(ret=None):
1617                         if not ret: return
1618                         data = self["bookmarklist"].getCurrent()[1]
1619                         if self.isCategoryItem():
1620                                 self.mBookmarkManager.deleteCategory(data.mId)
1621                         else:   self.mBookmarkManager.deleteBookmark(data.mId)
1622                         self.updateBookmarkList()
1623                 if self.isCategoryItem():
1624                         msg = _("Do you want to delete the category and the bookmarks?")
1625                 else:   msg = _("Do you want to delete the bookmark?")
1626                 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1627         def keyOK(self):
1628                 if self.isCategoryItem(): return
1629
1630                 data = self["bookmarklist"].getCurrent()[1]
1631                 url = data.mUrl.strip()
1632                 if len(url) == 0:
1633                         self.session.open(MessageBox, _("Can't open selected bookmark.\n   - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1634                         return
1635                 mode = data.mType
1636                 if mode:
1637                         lang = language.getLanguage()
1638                         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1639                                 url = '/usr/local/manual/ru_RU/main.html'
1640                         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1641                                 url = '/usr/local/manual/de_DE/main.html'
1642                 self.close((url, mode))
1643         def keyRed(self):
1644                 self.keyCancel()
1645         def keyCancel(self):
1646                 self.close()
1647
1648 class BrowserHelpWindow(Screen, HelpableScreen):
1649         MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1650         skin =  """
1651                 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1652                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1653                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1654                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1655                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1656
1657                         <widget source="key_red" render="Label" position="5,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1658                         <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" />
1659                         <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" />
1660                         <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" />
1661                 </screen>
1662                 """
1663         def __init__(self, session):
1664                 Screen.__init__(self, session)
1665                 HelpableScreen.__init__(self)
1666
1667                 self["key_red"]    = StaticText(_("Exit"))
1668                 self["key_green"]  = StaticText(_("Global"))
1669                 self["key_yellow"] = StaticText(_("Mouse"))
1670                 self["key_blue"]   = StaticText(_("Keyboard"))
1671
1672                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1673                                 "ok"    : self.keyRed,
1674                                 "cancel": self.keyRed,
1675                                 "red"   : self.keyRed,
1676                                 "green" : self.keyGreen,
1677                                 "yellow": self.keyYellow,
1678                                 "blue"  : self.keyBlue,
1679                         },-2)
1680
1681                 self.showHelpTimer = eTimer()
1682                 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1683                 self.showHelpTimer.start(500)
1684
1685                 self.onLayoutFinish.append(self.layoutFinished)
1686
1687         def layoutFinished(self):
1688                 self.setTitle(_('Browser Help'))
1689
1690         def cbShowHelpTimerClosed(self):
1691                 self.showHelpTimer.stop()
1692                 self.setHelpModeActions(self.MODE_GLOBAL)
1693
1694         def setHelpModeActions(self, _mode=0):
1695                 self.helpList = []
1696                 if _mode == self.MODE_GLOBAL:
1697                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1698                                 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1699                         })
1700                         self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1701                                 "menu" : (self.keyPass, _("Show the Menu window.")),
1702                         })
1703                         self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1704                                 "green"  : (self.keyPass, _("Enter Key")),
1705                                 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1706                                 "blue"   : (self.keyPass, _("Backspace Key")),
1707                         })
1708                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1709                                 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1710                         })
1711
1712                 elif _mode == self.MODE_MOUSE:
1713                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1714                                 "up"    : (self.keyPass, _("It will move the mouse pointer up.")),
1715                                 "down"  : (self.keyPass, _("It will move the mouse pointer down.")),
1716                                 "left"  : (self.keyPass, _("It will move the mouse pointer left.")),
1717                                 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1718                         })
1719                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1720                                 "ok" : (self.keyPass, _("Left Mouse Button")),
1721                         })
1722                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1723                                 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1724                                 "nextService" : (self.keyPass, _("Left Key")),
1725                                 "prevService" : (self.keyPass, _("Right Key")),
1726                         })
1727                 elif _mode == self.MODE_KEYBOARD:
1728                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1729                                 "up"    : (self.keyPass, _("Up Key")),
1730                                 "down"  : (self.keyPass, _("Down Key")),
1731                                 "left"  : (self.keyPass, _("Left Key")),
1732                                 "right" : (self.keyPass, _("Right Key")),
1733                         })
1734                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1735                                 "ok" : (self.keyPass, _("Enter Key")),
1736                         })
1737                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1738                                 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1739                                 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1740                                 "nextService" : (self.keyPass, _("Go to previous page.")),
1741                                 "prevService" : (self.keyPass, _("Go to next page.")),
1742                         })
1743
1744                 if _mode > 0:
1745                         self.showHelp()
1746
1747         def keyPass(self):
1748                 pass
1749
1750         def keyRed(self):
1751                 self.close()
1752         def keyGreen(self):
1753                 self.setHelpModeActions(self.MODE_GLOBAL)
1754         def keyYellow(self):
1755                 self.setHelpModeActions(self.MODE_MOUSE)
1756         def keyBlue(self):
1757                 self.setHelpModeActions(self.MODE_KEYBOARD)
1758
1759 class OperaBrowser(Screen):
1760         MENUBAR_ITEM_WIDTH  = 150
1761         MENUBAR_ITEM_HEIGHT = 30
1762         SUBMENULIST_WIDTH   = 200
1763         SUBMENULIST_HEIGHT  = 25
1764         SUBMENULIST_NEXT    = 2
1765
1766         # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1767         # menulist->size->x     : SUBMENULIST_WIDTH
1768         # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1769         # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1770         # submenulist->size->x  : SUBMENULIST_WIDTH
1771
1772         size = getDesktop(0).size()
1773         WIDTH  = int(size.width())
1774         HEIGHT = int(size.height())
1775         skin =  """
1776                 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1777                         <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1778                         <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1779                         <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1780                         <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1781                         <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1782                         <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1783                         <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1784                 </screen>
1785                 """ % { 'width'  :WIDTH,
1786                         'height' :HEIGHT,
1787                         'bottom_pos_y'  :HEIGHT-80,
1788                         'bottom_size_x' :WIDTH }
1789
1790         COMMAND_MAP = {}
1791         MENUITEMS_LIST =[]
1792         def __init__(self, session, url=None):
1793                 Screen.__init__(self, session)
1794                 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1795                          "cancel"      : self.keyCancel
1796                         ,"ok"          : self.keyOK
1797                         ,"left"        : self.keyLeft
1798                         ,"right"       : self.keyRight
1799                         ,"up"          : self.keyUp
1800                         ,"down"        : self.keyDown
1801                         ,"menu"        : self.keyMenu
1802                 }, -2)
1803
1804                 self.UpdateLanguageCB()
1805
1806                 self._terminatedBrowser = True
1807                 self._enableKeyEvent = True
1808                 self._currentPageUrl = None
1809                 self._currentPageTitle = None
1810                 self.menubarCurrentIndex = 0
1811                 self.lvMenuItems = []
1812                 self.lvSubMenuItems = []
1813
1814                 self["topArea"]    = Label()
1815                 self["bottomArea"] = Label()
1816
1817                 self["menuitemFile"] = MultiColorLabel()# modify menu
1818                 self["menuitemTool"] = MultiColorLabel()
1819                 self["menuitemHelp"] = MultiColorLabel()
1820
1821                 self["menulist"] = MenuList(self.setListOnView())
1822                 self["submenulist"] = MenuList(self.setSubListOnView())
1823
1824                 self.toggleMainScreenFlag = True
1825                 self.toggleListViewFlag = False
1826                 self.toggleSubListViewFlag = False
1827                 self.currentListView = self["menulist"]
1828
1829                 self.onLayoutFinish.append(self.layoutFinished)
1830
1831                 self._onCloseTimer = eTimer()
1832                 self._onCloseTimer.callback.append(self._cb_onClose)
1833
1834                 self.paramUrl = url
1835                 language.addCallback(self.UpdateLanguageCB)
1836
1837         def UpdateLanguageCB(self):
1838                 # modify menu
1839                 self.MENUITEMS_LIST = [
1840                         [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1841                         [(_('Bookmark'), None), (_('Preference'), None)],
1842                         [(_('About'), None), (_('Help'), None)]]
1843                 self.COMMAND_MAP = {}
1844                 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1845                 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1846                 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1847                 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1848                 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1849                 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1850                 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1851                 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1852                 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1853
1854         def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1855                 rcmouse_path = "/proc/stb/fp/mouse"
1856                 if os.path.exists(rcmouse_path):
1857                         os.system("echo %d > %s" % (mode, rcmouse_path))
1858
1859         def layoutFinished(self):
1860                 self["menuitemFile"].setText(_("File"))# modify menu
1861                 self["menuitemTool"].setText(_("Tools"))
1862                 self["menuitemHelp"].setText(_("Help"))
1863
1864                 self["menulist"].hide()
1865                 self["submenulist"].hide()
1866
1867                 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1868                 self.setTitle(_("BrowserMain"))
1869                 self.selectMenuitem()
1870
1871                 if self.paramUrl is not None:
1872                         self.keyMenu()
1873                         self.cbUrlText(self.paramUrl, 1)
1874
1875         def selectMenuitem(self):
1876                 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1877                 self["menuitemFile"].setForegroundColorNum(0)
1878                 self["menuitemTool"].setForegroundColorNum(0)
1879                 self["menuitemHelp"].setForegroundColorNum(0)
1880                 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1881
1882         def popupCloseAll(self):
1883                 self.keyLeft()
1884                 self.keyLeft()
1885                 self.keyUp()
1886                 self.keyCancel()
1887
1888         def setListOnView(self):
1889                 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1890                 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1891                         l = [(_('Return'), None)]
1892                 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1893                 return self.lvMenuItems
1894
1895         def setSubListOnView(self):
1896                 self.lvSubMenuItems = []
1897                 xl = self["menulist"].getCurrent()[1]
1898                 if xl is None: return []
1899                 for x in xl:
1900                         self.lvSubMenuItems.append((x,None))
1901                 return self.lvSubMenuItems
1902
1903         def toggleMainScreen(self):
1904                 if not self.toggleMainScreenFlag:
1905                         self.show()
1906                 else:   self.hide()
1907                 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1908
1909         def toggleListView(self):
1910                 if not self.toggleListViewFlag:
1911                         self["menulist"].show()
1912                 else:   self["menulist"].hide()
1913                 self.toggleListViewFlag = not self.toggleListViewFlag
1914
1915         def toggleSubListView(self):
1916                 if not self.toggleSubListViewFlag:
1917                         self["submenulist"].show()
1918                 else:   self["submenulist"].hide()
1919                 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1920
1921         def setCurrentListView(self, listViewIdx):
1922                 if listViewIdx == 0:
1923                         self.currentListView = None
1924                 elif listViewIdx == 1:
1925                         self.currentListView = self["menulist"]
1926                 elif listViewIdx == 2:
1927                         self.currentListView = self["submenulist"]
1928
1929         def _cb_onClose(self):
1930                 self._onCloseTimer.stop()
1931                 command_server = getCommandServer()
1932                 try:
1933                         if self._on_close_window in command_server.onHbbTVCloseCB:
1934                                         command_server.onHbbTVCloseCB.remove(self._on_close_window)
1935                 except Exception, ErrMsg: pass
1936                 try:
1937                         if self._on_setPageTitle in command_server.onSetPageTitleCB:
1938                                 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1939                 except Exception, ErrMsg: pass
1940                 self._on_setPageTitle(_('Opera Browser'))
1941                 self.enableRCMouse(False)
1942                 self.toggleMainScreen()
1943                 restoreResolution()
1944                 fbClass.getInstance().unlock()
1945                 eRCInput.getInstance().unlock()
1946                 self._terminatedBrowser = True
1947                 self._enableKeyEvent = True
1948                 #if not self.toggleListViewFlag:
1949                 #       self.keyDown()
1950
1951                 self._currentPageUrl = ''
1952                 if self.paramUrl is not None:
1953                         self.keyCancel()
1954                 else:
1955                         self.keyRight()
1956                         self.keyLeft()
1957
1958         def _on_setPageTitle(self, title=None):
1959                 print "Title :",title
1960                 if title is None:
1961                         return
1962                 self.setTitle(title)
1963
1964         def cbUrlText(self, data=None, mode=0):
1965                 global _g_helper
1966                 if not _g_helper._is_browser_running():
1967                         return
1968                 print "Inputed Url :", data, mode
1969                 if strIsEmpty(data):
1970                         return
1971                 #self.hideSubmenu()
1972                 command_server = getCommandServer()
1973                 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1974                                 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1975                 if self._on_close_window not in command_server.onHbbTVCloseCB:
1976                         command_server.onHbbTVCloseCB.append(self._on_close_window)
1977                 self.toggleMainScreen()
1978                 self.enableRCMouse(True)
1979
1980                 fbClass.getInstance().lock()
1981                 eRCInput.getInstance().lock()
1982
1983                 setResolution(1280, 720)
1984
1985                 command_util = getCommandUtil()
1986                 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1987                 self._terminatedBrowser = False
1988                 self._enableKeyEvent = False
1989
1990         def _on_close_window(self):
1991                 self._onCloseTimer.start(1000)
1992
1993         def _cb_bookmarkWindowClosed(self, data=None):
1994                 if data is None:
1995                         return
1996                 (url, mode) = data
1997                 global _g_helper
1998                 if not _g_helper._is_browser_running():
1999                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2000                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2001                         return
2002                 self.cbUrlText(url, mode)
2003
2004         def _cmd_on_OpenUrl(self):
2005                 global _g_helper
2006                 if not _g_helper._is_browser_running():
2007                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2008                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2009                         return
2010                 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2011         def _cmd_on_About(self):
2012                 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2013         def _cmd_on_Exit(self):
2014                 self.close()
2015         def _cb_cmdOnStartSTop(self):
2016                 self.keyMenu()
2017         def _cmd_on_StartStop(self):
2018                 global _g_helper
2019                 if _g_helper is None:
2020                         return
2021                 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2022
2023         def _cmd_on_Bookmark(self):
2024                 url = self._currentPageUrl
2025                 if url is None:
2026                         url = ''
2027                 title = self._currentPageTitle
2028                 if title is None:
2029                         title = ''
2030                 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2031         def _cmd_on_Preference(self):
2032                 url = self._currentPageUrl
2033                 if url is None:
2034                         url = ''
2035                 self.session.open(OperaBrowserPreferenceWindow, url)
2036         def _cmd_on_OpenStartpage(self):
2037                 global _g_helper
2038                 if not _g_helper._is_browser_running():
2039                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2040                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2041                         return
2042                 mode = 0
2043                 start = 'http://vuplus.com'
2044                 try:
2045                         d = OperaBrowserSetting().getData()
2046                         start = d['start']
2047                         mode = d['type']
2048                 except: pass
2049                 self.cbUrlText(start, mode)
2050         def _cmd_on_ReturnToBrowser(self):
2051                 self.keyCancel()
2052
2053         def _cmd_on_Help(self):
2054                 self.session.open(BrowserHelpWindow)
2055
2056         def doCommand(self, command):
2057                 try:
2058                         self.COMMAND_MAP[command]()
2059                 except Exception, ErrMsg: print ErrMsg
2060
2061         def keyOK(self):
2062                 if not self.toggleMainScreenFlag:
2063                         self.keyMenu()
2064                         return
2065                 if not self.toggleListViewFlag:
2066                         self.keyDown()
2067                         return
2068                 if self.currentListView.getCurrent()[1] is None:
2069                         self.doCommand(self.currentListView.getCurrent()[0])
2070                         #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2071                         return
2072                 self.keyRight()
2073
2074         def updateSelectedMenuitem(self, status):
2075                 if self.menubarCurrentIndex == 0 and status < 0:
2076                         self.menubarCurrentIndex = 2 # modify menu
2077                 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2078                         self.menubarCurrentIndex = 0
2079                 else:   self.menubarCurrentIndex += status
2080                 self.selectMenuitem()
2081
2082         def keyLeft(self):
2083                 if not self.toggleMainScreenFlag:
2084                         return
2085                 if not self.toggleListViewFlag:
2086                         self.updateSelectedMenuitem(-1)
2087                         return
2088                 if self.toggleSubListViewFlag:
2089                         self.setCurrentListView(1)
2090                         self.toggleSubListView()
2091                         return
2092                 #if self.currentListView.getSelectedIndex():
2093                 self.currentListView.pageUp()
2094                 self.keyUp()
2095                 self.keyLeft()
2096                 self.keyDown()
2097
2098         def keyRight(self):
2099                 if not self.toggleMainScreenFlag:
2100                         return
2101                 if not self.toggleListViewFlag:
2102                         self.updateSelectedMenuitem(1)
2103                         return
2104                 if self.currentListView is None:
2105                         return
2106                 if self.currentListView.getCurrent()[1] is not None:
2107                         parentSelectedIndex = self.currentListView.getSelectedIndex()
2108                         self.setCurrentListView(2)
2109                         self.currentListView.setList(self.setSubListOnView())
2110                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2111                         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))
2112                         self.toggleSubListView()
2113                         return
2114                 self.currentListView.pageUp()
2115                 self.keyUp()
2116                 self.keyRight()
2117                 self.keyDown()
2118
2119         def keyDown(self):
2120                 if not self.toggleMainScreenFlag:
2121                         return
2122                 if self.currentListView is None:
2123                         return
2124                 if not self.toggleListViewFlag:
2125                         self.currentListView.setList(self.setListOnView())
2126                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2127                         self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2128                         self.toggleListView()
2129                         return
2130                 self.currentListView.down()
2131
2132         def keyUp(self):
2133                 if not self.toggleMainScreenFlag:
2134                         return
2135                 if self.currentListView is None:
2136                         return
2137                 if self.currentListView == self["menulist"]:
2138                         if self.currentListView.getSelectedIndex() == 0:
2139                                 self.toggleListView()
2140                                 return
2141                 self.currentListView.up()
2142
2143         def keyCancel(self):
2144                 if not self._terminatedBrowser:
2145                         #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2146                         fbClass.getInstance().lock()
2147                         eRCInput.getInstance().lock()
2148                         setResolution(1280, 720)
2149                         if self.toggleListViewFlag:
2150                                 self.toggleMainScreen()
2151                         self._currentPageUrl   = None
2152                         self._currentPageTitle = None
2153                         command_util = getCommandUtil()
2154                         command_util.sendCommand('OP_BROWSER_MENU_RES')
2155                         return
2156                 self.close()
2157
2158         def keyMenu(self):
2159                 self.toggleMainScreen()
2160
2161         def setCurrentPageUrl(self, url, title=None):
2162                 self._currentPageUrl = url
2163                 if title is None:
2164                         idx = len(url)
2165                         if idx > 10: idx = 10
2166                         title = url[:idx]
2167                 self._currentPageTitle = title
2168                 print self._currentPageUrl
2169                 self.toggleMainScreen()
2170                 self.hideSubmenu()
2171                 self.keyDown()
2172
2173         def hideSubmenu(self):
2174                 self.currentListView.pageUp()
2175                 self.keyUp()
2176
2177 def auto_start_main(reason, **kwargs):
2178         if reason:
2179                 command_server = getCommandServer()
2180                 command_server.stop()
2181
2182 from  Screens.HelpMenu import HelpableScreen
2183 def session_start_main(session, reason, **kwargs):
2184         fbClass.getInstance().unlock()
2185         eRCInput.getInstance().unlock()
2186
2187         from enigma import getDesktop
2188         desktopSize = getDesktop(0).size()
2189         setDefaultResolution(desktopSize.width(), desktopSize.height())
2190
2191         global _g_helper
2192         _g_helper = session.open(HbbTVHelper)
2193
2194         HelpableScreen.__init__ = HelpableScreen__init__
2195         HelpableScreen.session = session
2196
2197 def HelpableScreen__init__(self):
2198         if isinstance(self, HelpableScreen):
2199                 HelpableScreen.showManual = showManual
2200
2201                 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2202                         "help_b" : self.showHelp,
2203                         "help_l" : self.showManual,
2204                 }, -2)
2205
2206 _g_clearBrowserDataTimer = eTimer()
2207 def showManual(self):
2208         if not os.path.exists('/usr/local/manual'):
2209                 return
2210
2211         url = 'file:///usr/local/manual/main.html'
2212         lang = language.getLanguage()
2213         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2214                 url = 'file:///usr/local/manual/ru_RU/main.html'
2215         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2216                 url = 'file:///usr/local/manual/de_DE/main.html'
2217
2218         def _do_clean():
2219                 _g_clearBrowserDataTimer.stop()
2220                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2221                 except: pass
2222                 setPluginBrowser(None)
2223         def clearBrowserData():
2224                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2225                 _g_clearBrowserDataTimer.start(50)
2226         setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2227
2228 def plugin_start_main(session, **kwargs):
2229         #session.open(OperaBrowser)
2230         def _do_clean():
2231                 _g_clearBrowserDataTimer.stop()
2232                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2233                 except: pass
2234                 setPluginBrowser(None)
2235         def clearBrowserData():
2236                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2237                 _g_clearBrowserDataTimer.start(50)
2238         setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2239
2240 def plugin_extension_start_application(session, **kwargs):
2241         global _g_helper
2242         if _g_helper is None:
2243                 return
2244         _g_helper.showApplicationSelectionBox()
2245
2246 def plugin_extension_browser_config(session, **kwargs):
2247         global _g_helper
2248         if _g_helper is None:
2249                 return
2250         _g_helper.showBrowserConfigBox()
2251
2252 def Plugins(path, **kwargs):
2253         l = []
2254         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2255         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2256         l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2257         l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2258         l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))
2259
2260         return l
2261