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                                 print "Try to open vod"
 785                                 self._vod_service = eServiceReference(4097, 0, url)
 786                                 self._session.nav.playService(self._vod_service)
 787                                 if self._vod_service is not None:
 788                                         return True
 789                         except Exception, ErrMsg:
 790                                 print "OpenVOD ERR :", ErrMsg
 791                         time.sleep(1)
 792                 return False
 793
 794         def _cb_handleVODPlayerPlay(self, opcode, data):
 795                 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
 796                 self.doStop(restoreBeforeService=False)
 797                 if self.doRetryOpen(url=self._vod_uri) == False:
 798                         self.doStop()
 799                 return (0, "OK")
 800
 801         def _cb_handleVODPlayerStop(self, opcode, data):
 802                 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
 803                 self.doStop()
 804                 return (0, "OK")
 805
 806         def _cb_handleVODPlayerPlayPause(self, opcode, data):
 807                 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
 808                 service = self._session.nav.getCurrentService()
 809                 try:
 810                         pauseFlag = data[0]
 811                         servicePause = service.pause()
 812                         if pauseFlag == 'U':
 813                                 servicePause.unpause()
 814                         elif pauseFlag == 'P':
 815                                 servicePause.pause()
 816                 except Exception, ErrMsg:
 817                         print "onPause ERR :", ErrMsg
 818                 return (0, "OK")
 819
 820 from libshm import SimpleSharedMemory
 821 _g_ssm_ = None
 822 class HbbTVWindow(Screen, InfoBarNotifications):
 823         skin =  """
 824                 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
 825                 </screen>
 826                 """
 827         def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
 828                 self._session = session
 829                 setResolution(1280, 720)
 830                 fbClass.getInstance().lock()
 831                 eRCInput.getInstance().lock()
 832
 833                 Screen.__init__(self, session)
 834                 InfoBarNotifications.__init__(self)
 835                 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
 836                         iPlayableService.evUser+20: self._serviceForbiden,
 837                         iPlayableService.evStart: self._serviceStarted,
 838                         iPlayableService.evEOF: self._serviceEOF,
 839                 })
 840
 841                 self._url = url
 842                 self._use_ait = useAIT
 843                 self._profile = profile
 844                 self._cb_closed_func = cbf
 845                 self.onLayoutFinish.append(self._layoutFinished)
 846
 847                 command_server = getCommandServer()
 848                 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
 849                         command_server.onSetPageTitleCB.append(self._cb_set_page_title)
 850
 851                 if self._cb_close_window not in command_server.onHbbTVCloseCB:
 852                         command_server.onHbbTVCloseCB.append(self._cb_close_window)
 853
 854                 self._closeTimer = eTimer()
 855                 self._closeTimer.callback.append(self._do_close)
 856
 857                 self._currentServicePositionTimer = eTimer()
 858                 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
 859                 self._vodLength = 0
 860
 861                 global _g_ssm_
 862                 self._ssm = _g_ssm_
 863                 self._vod_length = 0
 864
 865         def getVodPlayTime(self):
 866                 try:
 867                         service = self._session.nav.getCurrentService()
 868                         seek = service and service.seek()
 869                         l = seek.getLength()
 870                         p = seek.getPlayPosition()
 871                         #return (p[1]/90000, l[1]/90000)
 872                         return (p[1], l[1])
 873                 except: pass
 874                 return (-1,-1)
 875
 876         def _cb_currentServicePosition(self):
 877                 def getTimeString(t):
 878                         t = time.localtime(t/90000)
 879                         return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
 880                 position,length = 0,0
 881                 try:
 882                         (position,length) = self.getVodPlayTime()
 883                         self._vod_length = length
 884                         if position == -1 and length == -1:
 885                                 raise Exception("Can't get play status")
 886                         #print getTimeString(position), "/", getTimeString(length)
 887                         self._ssm.setStatus(position, length, 1)
 888                 except Exception, ErrMsg:
 889                         print ErrMsg
 890                         self._serviceEOF()
 891
 892         def _serviceStarted(self):
 893                 try:
 894                         self._ssm.setStatus(0, 0, 0)
 895                         self._currentServicePositionTimer.start(1000)
 896                 except Exception, ErrMsg:
 897                         print ErrMsg
 898
 899         def _serviceEOF(self):
 900                 (position,length) = self.getVodPlayTime()
 901                 self._ssm.setStatus(length, length, 1)
 902                 print "service EOF"
 903                 self._currentServicePositionTimer.stop()
 904
 905         def _layoutFinished(self):
 906                 self.setTitle(_('HbbTV Plugin'))
 907                 command_util = getCommandUtil()
 908                 profile = self._profile
 909                 (sid, onid, tsid, name, orgid) = getChannelInfos()
 910                 params  = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
 911                 if self._use_ait:
 912                         command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
 913                         time.sleep(1)
 914                         command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
 915                         return
 916                 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
 917                 time.sleep(1)
 918                 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
 919
 920         def _cb_close_window(self):
 921                 self._closeTimer.start(1000)
 922
 923         def _do_close(self):
 924                 self._closeTimer.stop()
 925                 command_server = getCommandServer()
 926                 try:
 927                         if self._cb_set_page_title in command_server.onSetPageTitleCB:
 928                                 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
 929                 except Exception, ErrMsg: pass
 930                 try:
 931                         if self._cb_close_window in command_server.onHbbTVCloseCB:
 932                                         command_server.onHbbTVCloseCB.remove(self._cb_close_window)
 933                 except Exception, ErrMsg: pass
 934                 try:
 935                         if self._cb_closed_func is not None:
 936                                 self._cb_closed_func()
 937                 except: pass
 938                 restoreResolution()
 939                 fbClass.getInstance().unlock()
 940                 eRCInput.getInstance().unlock()
 941                 self.close()
 942
 943         def _serviceForbiden(self):
 944                 global __gval__
 945                 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
 946                 #print "Received URI :\n", real_url
 947
 948                 if real_url is not None:
 949                         __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
 950
 951         def _cb_set_page_title(self, title=None):
 952                 print "page title :",title
 953                 if title is None:
 954                         return
 955                 self.setTitle(title)
 956
 957 class HbbTVHelper(Screen):
 958         skin =  """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
 959         def __init__(self, session):
 960                 global __gval__
 961                 __gval__.hbbtv_handelr = HandlerHbbTV(session)
 962                 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
 963
 964                 self._urls = None
 965
 966                 Screen.__init__(self, session)
 967                 self._session = session
 968
 969                 self._restart_opera()
 970
 971                 self._timer_infobar = eTimer()
 972                 self._timer_infobar.callback.append(self._cb_registrate_infobar)
 973                 self._timer_infobar.start(1000)
 974
 975                 self._excuted_browser = False
 976                 self._profile = 0
 977
 978                 __gval__.command_util = BrowserCommandUtil()
 979
 980                 global _g_ssm_
 981                 if _g_ssm_ is None:
 982                         _g_ssm_ = SimpleSharedMemory()
 983                         _g_ssm_.doConnect()
 984
 985                 self._callbackStartStop = None
 986
 987         def _cb_registrate_infobar(self):
 988                 if InfoBar.instance:
 989                         self._timer_infobar.stop()
 990                         if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
 991                                 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
 992                         if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
 993                                 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
 994
 995         def _cb_ready_for_ait(self, orgId=0):
 996                 if orgId == 0:
 997                         if not self._excuted_browser:
 998                                 command_util = getCommandUtil()
 999                                 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1000                         return
1001                 setChannelInfo(None, None, None, None, None)
1002
1003                 service = self._session.nav.getCurrentService()
1004                 info = service and service.info()
1005                 if info is not None:
1006                         sid  = info.getInfo(iServiceInformation.sSID)
1007                         onid = info.getInfo(iServiceInformation.sONID)
1008                         tsid = info.getInfo(iServiceInformation.sTSID)
1009                         name = info.getName()
1010                         if name is None:
1011                                 name = ""
1012                         orgid   = 0
1013                         namelen = len(name)
1014                         for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
1015                                 if x[0] in (1, -1) :
1016                                         orgid = x[3]
1017                                         break
1018                         setChannelInfo(sid, onid, tsid, name, orgid)
1019
1020         def _cb_hbbtv_activated(self, title=None, url=None):
1021                 if not self._is_browser_running():
1022                         message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1023                         self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1024                         return
1025                 service = self._session.nav.getCurrentlyPlayingServiceReference()
1026                 setBeforeService(service)
1027                 self._start_hbbtv_application(title, url)
1028
1029         def _start_hbbtv_application(self, title, url):
1030                 use_ait = False
1031                 tmp_url = self.getStartHbbTVUrl()
1032                 if url is None:
1033                         url = tmp_url
1034                 if strIsEmpty(url):
1035                         print "can't get url of hbbtv!!"
1036                         return
1037                 print "success to get url of hbbtv!! >>", url
1038                 if self._excuted_browser:
1039                         print "already excuted opera browser!!"
1040                         return
1041
1042                 if isNeedRestart():
1043                         self._restart_opera()
1044                         time.sleep(2)
1045                         setNeedRestart(False)
1046
1047                 for x in self._urls:
1048                         control_code = x[0]
1049                         tmp_url = x[2]
1050                         if tmp_url == url and control_code == 1:
1051                                 use_ait = True
1052                 self._excuted_browser = True
1053                 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1054
1055         def _cb_closed_browser(self):
1056                 self._excuted_browser = False
1057
1058         def _start_opera(self):
1059                 if not self._is_browser_running():
1060                         global HBBTVAPP_PATH
1061                         start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1062                         os.system(start_command)
1063                 return True
1064
1065         def _stop_opera(self):
1066                 global HBBTVAPP_PATH
1067                 try:    os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1068                 except: pass
1069
1070         def _restart_opera(self):
1071                 global HBBTVAPP_PATH
1072                 try:    os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1073                 except: pass
1074                 return True
1075
1076         def getStartHbbTVUrl(self):
1077                 url, self._urls, self._profile = None, None, 0
1078                 service = self._session.nav.getCurrentService()
1079                 info = service and service.info()
1080                 if not info: return None
1081                 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1082                 for u in self._urls:
1083                         if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1084                                 url = u[2]
1085                                 self._profile = u[5]
1086                 if url is None:
1087                         url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1088                 return url
1089
1090         def showApplicationSelectionBox(self):
1091                 applications = []
1092
1093                 if self.getStartHbbTVUrl():
1094                         for x in self._urls:
1095                                 applications.append((x[1], x))
1096                 else: applications.append((_("No detected HbbTV applications."), None))
1097                 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1098
1099         def _application_selected(self, selected):
1100                 try:
1101                         if selected[1] is None: return
1102                         self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1103                 except Exception, ErrMsg: print ErrMsg
1104
1105         def showBrowserConfigBox(self, callback=None):
1106                 start_stop_mode = []
1107                 self._callbackStartStop = callback
1108                 if self._is_browser_running():
1109                         start_stop_mode.append((_('Stop'),'Stop'))
1110                 else:   start_stop_mode.append((_('Start'),'Start'))
1111                 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1112
1113         def _browser_config_selected(self, selected):
1114                 if selected is None:
1115                         return
1116                 if self._callbackStartStop is not None:
1117                         self._callbackStartStop()
1118                 try:
1119                         mode = selected[1]
1120                         if mode == 'Start':
1121                                 if not self._is_browser_running():
1122                                         self._start_opera()
1123                         elif mode == 'Stop':
1124                                 self._stop_opera()
1125                 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1126
1127         def _is_browser_running(self):
1128                 try:
1129                         global HBBTVAPP_PATH
1130                         ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1131                         return ret.strip() != "0"
1132                 except Exception, ErrMsg:
1133                         print "Check Browser Running ERR :", ErrMsg
1134                 return False
1135
1136         def doChangeChannel(self, _sid, _tsid):
1137                 root = eServiceReference(service_types_tv)
1138                 if root is None:
1139                         return False
1140                 serviceList = eServiceCenter.getInstance().list(root)
1141                 if serviceList is None:
1142                         return False
1143                 while True:
1144                         service = serviceList.getNext()
1145                         if service is None or not service.valid():
1146                                 break
1147
1148                         #1:0:19:2840:3FB:1:C00000:0:0:0:
1149                         serviceRef = service.toString()
1150                         if strIsEmpty(serviceRef):
1151                                 continue
1152                         serviceRefItems = serviceRef.split(":")
1153                         if len(serviceRefItems) < 5:
1154                                 continue
1155
1156                         sid  = serviceRefItems[3]
1157                         tsid = serviceRefItems[4]
1158                         if sid == _sid and tsid == _tsid:
1159                                 self._session.nav.playService(eServiceReference(serviceRef))
1160                                 service = self._session.nav.getCurrentlyPlayingServiceReference()
1161                                 setBeforeService(service)
1162                                 return True
1163                 return False
1164
1165 class OperaBrowserSetting:
1166         def __init__(self):
1167                 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1168                 self._start = None
1169                 self._type  = None
1170                 self._keymap = None
1171                 self._read()
1172         def _read(self):
1173                 f = open(self._settingFileName)
1174                 for line in f.readlines():
1175                         if line.startswith('start='):
1176                                 tmp = line[6:len(line)-1].split()
1177                                 self._start = tmp[0]
1178                                 if len(tmp) > 1:
1179                                         self._type = int(tmp[1])
1180                                 else:   self._type = 0
1181                         elif line.startswith('keymap='):
1182                                 self._keymap = line[7:len(line)-1]
1183                 f.close()
1184         def _write(self):
1185                 tmpstr = []
1186                 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1187                 tmpstr.append('keymap=%s\n' % (self._keymap))
1188                 f = open(self._settingFileName, 'w')
1189                 f.writelines(tmpstr)
1190                 f.close()
1191         def setData(self, start, types=0, keymap="us-rc"):
1192                 self._start = start
1193                 self._type = types
1194                 self._keymap = keymap
1195                 self._write()
1196         def getData(self):
1197                 return {
1198                         'start':self._start,
1199                         'type':self._type,
1200                         'keymap':self._keymap,
1201                 }
1202
1203 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1204         skin=   """
1205                 <screen position="center,120" size="600,350" title="Preference">
1206                         <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1207                         <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1208
1209                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1210                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1211
1212                         <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" />
1213                         <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" />
1214                 </screen>
1215                 """
1216         def __init__(self, session, currentUrl):
1217                 self.session = session
1218                 Screen.__init__(self, session)
1219
1220                 self.menulist = []
1221                 ConfigListScreen.__init__(self, self.menulist)
1222
1223                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1224                         "red"    : self.keyRed,
1225                         "green"  : self.keyGreen,
1226                         "ok"     : self.keyOK,
1227                         "cancel" : self.keyRed
1228                 }, -2)
1229                 self["key_red"]   = StaticText(_("Cancel"))
1230                 self["key_green"] = StaticText(_("Save"))
1231                 self["url"]       = Label()
1232
1233                 self._currentPageUrl = currentUrl
1234                 if self._currentPageUrl is None:
1235                         self._currentPageUrl = ''
1236                 self._startPageUrl   = None
1237                 self._keymapType = None
1238                 self.makeMenuEntry()
1239                 self.onLayoutFinish.append(self.layoutFinished)
1240
1241         def layoutFinished(self):
1242                 self.setTitle(_('Preference'))
1243
1244         def updateStartPageUrl(self):
1245                 if self.menuItemStartpage.value == "startpage":
1246                         self["url"].setText(self._startPageUrl)
1247                 elif self.menuItemStartpage.value == "current":
1248                         self["url"].setText(self._currentPageUrl)
1249                 elif self.menuItemStartpage.value == "direct":
1250                         self["url"].setText('')
1251
1252         def keyGreen(self):
1253                 url = self["url"].getText()
1254                 if strIsEmpty(url):
1255                         self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1256                         return
1257                 mode = 0
1258                 if url.find('/usr/local/manual') > 0:
1259                         mode = 1
1260                 self._keymapType = self.menuItemKeyboardLayout.value
1261                 OperaBrowserSetting().setData(url, mode, self._keymapType)
1262                 command_util = getCommandUtil()
1263                 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1264                 self.close()
1265
1266         def keyRed(self):
1267                 self.close()
1268
1269         def keyOK(self):
1270                 def _cb_directInputUrl(data):
1271                         if strIsEmpty(data):
1272                                 return
1273                         self["url"].setText(data)
1274                 if self.menuItemStartpage.value == "direct":
1275                         self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1276
1277         def keyLeft(self):
1278                 ConfigListScreen.keyLeft(self)
1279                 self.updateStartPageUrl()
1280
1281         def keyRight(self):
1282                 ConfigListScreen.keyRight(self)
1283                 self.updateStartPageUrl()
1284
1285         def getKeymapTypeList(self):
1286                 types = []
1287                 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1288                         filesplit = f.split('.')
1289                         if len(filesplit) < 2:
1290                                 continue
1291                         types.append((filesplit[1], filesplit[1]))
1292                 types.sort()
1293                 return types
1294
1295         def makeMenuEntry(self):
1296                 l = []
1297                 l.append(("startpage", _("Start Page")))
1298                 if not strIsEmpty(self._currentPageUrl):
1299                         l.append(("current", _("Current Page")))
1300                 l.append(("direct", _("Direct Input")))
1301                 self.menuItemStartpage  = ConfigSelection(default="startpage", choices = l)
1302                 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1303
1304                 kl = self.getKeymapTypeList()
1305
1306                 try:
1307                         d = OperaBrowserSetting().getData()
1308                         self._startPageUrl = d['start']
1309                         self._keymapType = d['keymap']
1310                         #d['type']
1311                 except: self._startPageUrl = 'http://vuplus.com'
1312                 self.updateStartPageUrl()
1313
1314                 if self._keymapType is None or len(self._keymapType) == 0:
1315                         self._keymapType = "us-rc"
1316                 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1317                 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1318                 self.resetMenuList()
1319
1320         def resetMenuList(self):
1321                 self.menulist = []
1322                 self.menulist.append(self.menuEntryStartpage)
1323                 self.menulist.append(self.menuEntryKeyboardLayout)
1324
1325                 self["config"].list = self.menulist
1326                 self["config"].l.setList(self.menulist)
1327
1328 class BookmarkEditWindow(ConfigListScreen, Screen):
1329         CATEGORY,BOOKMARK = 0,1
1330         skin=   """
1331                 <screen position="center,center" size="600,140" title="Bookmark Edit">
1332                         <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1333
1334                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1335                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1336
1337                         <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" />
1338                         <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" />
1339
1340                         <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1341
1342                 </screen>
1343                 """
1344         def __init__(self, session, _mode, _type, _data, _bm):
1345                 self.mMode = _mode
1346                 self.mType = _type
1347                 self.mData = _data
1348                 self.mSession = session
1349                 self.mBookmarkManager = _bm
1350
1351                 if _data is not None:
1352                         print _data.mId
1353
1354                 Screen.__init__(self, session)
1355
1356                 self.menulist = []
1357                 ConfigListScreen.__init__(self, self.menulist)
1358
1359                 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1360                         "ok"     : self.keyGreen,
1361                         "green"  : self.keyGreen,
1362                         "red"    : self.keyRed,
1363                         "cancel" : self.keyRed,
1364                 }, -2)
1365
1366                 self["VKeyIcon"]  = Pixmap()
1367                 self["key_red"]   = StaticText(_("Cancel"))
1368                 self["key_green"] = StaticText(_("Save"))
1369
1370                 self.menuItemTitle = None
1371                 self.menuItemUrl   = None
1372                 self.menuItemName  = None
1373
1374                 self.menuEntryName = None
1375                 self.menuEntryTitle = None
1376                 self.menuEntryUrl = None
1377
1378                 self.makeConfigList()
1379                 self.onLayoutFinish.append(self.layoutFinished)
1380
1381         def layoutFinished(self):
1382                 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1383
1384         def selectedItem(self):
1385                 currentPosition = self["config"].getCurrent()
1386                 if self.mType == BookmarkEditWindow.CATEGORY:
1387                         return (_("Name"), self.menuItemName)
1388                 else:
1389                         if currentPosition == self.menuEntryTitle:
1390                                 return (_("Title"), self.menuItemTitle)
1391                         elif currentPosition == self.menuEntryUrl:
1392                                 return (_("Url"), self.menuItemUrl)
1393                 return None
1394
1395         def showMessageBox(self, text):
1396                 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1397                 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1398                 return False
1399
1400         def showVKeyWindow(self, data=None):
1401                 itemTitle = ""
1402                 itemValue = ""
1403                 selected = self.selectedItem()
1404                 if selected is not None:
1405                         itemValue = selected[1].value
1406                         if strIsEmpty(itemValue):
1407                                 itemValue = ""
1408                         itemTitle = selected[0]
1409
1410                 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1411
1412         def cbVKeyWindow(self, data=None):
1413                 if data is not None:
1414                         selected = self.selectedItem()
1415                         if selected is not None:
1416                                 selected[1].setValue(data)
1417
1418         def saveData(self):
1419                 if self.mType == BookmarkEditWindow.CATEGORY:
1420                         if self.mMode == _('Add'):
1421                                 categoryName = self.menuItemName.value
1422                                 if strIsEmpty(categoryName):
1423                                         return self.showMessageBox(_("Category Name"))
1424                                 self.mBookmarkManager.addCategory(categoryName)
1425                         else:
1426                                 if strIsEmpty(self.menuItemName.value):
1427                                         return self.showMessageBox(_("Category Name"))
1428                                 self.mData.mName = self.menuItemName.value
1429                                 self.mBookmarkManager.updateCategory(self.mData)
1430                 else:
1431                         if self.mMode == _('Add'):
1432                                 bookmarkTitle = self.menuItemTitle.value
1433                                 bookmarkUrl   = self.menuItemUrl.value
1434                                 if strIsEmpty(bookmarkTitle):
1435                                         self["config"].setCurrentIndex(0)
1436                                         return self.showMessageBox(_("Bookmark Title"))
1437                                 if strIsEmpty(bookmarkUrl):
1438                                         self["config"].setCurrentIndex(1)
1439                                         return self.showMessageBox(_("Bookmark URL"))
1440                                 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1441                         else:
1442                                 if strIsEmpty(self.menuItemTitle.value):
1443                                         self["config"].setCurrentIndex(0)
1444                                         return self.showMessageBox(_("Bookmark Title"))
1445                                 if strIsEmpty(self.menuItemUrl.value):
1446                                         self["config"].setCurrentIndex(1)
1447                                         return self.showMessageBox(_("Bookmark URL"))
1448                                 self.mData.mTitle = self.menuItemTitle.value
1449                                 self.mData.mUrl   = self.menuItemUrl.value
1450                                 self.mBookmarkManager.updateBookmark(self.mData)
1451                 return True
1452
1453         def keyGreen(self):
1454                 if not self.saveData():
1455                         return
1456                 self.close(True)
1457         def keyRed(self):
1458                 self.close(False)
1459         def keyLeft(self):
1460                 ConfigListScreen.keyLeft(self)
1461         def keyRight(self):
1462                 ConfigListScreen.keyRight(self)
1463         def makeConfigList(self):
1464                 self.menulist = []
1465
1466                 if self.mType == BookmarkEditWindow.CATEGORY:
1467                         self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1468
1469                         self.menuEntryName  = getConfigListEntry(_("Name"), self.menuItemName)
1470
1471                         self.menulist.append(self.menuEntryName)
1472                 else:
1473                         self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1474                         self.menuItemUrl   = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1475
1476                         self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1477                         self.menuEntryUrl   = getConfigListEntry(_("Url"), self.menuItemUrl)
1478
1479                         self.menulist.append(self.menuEntryTitle)
1480                         self.menulist.append(self.menuEntryUrl)
1481
1482                 self["config"].list = self.menulist
1483                 self["config"].l.setList(self.menulist)
1484
1485 class OperaBrowserBookmarkWindow(Screen):
1486         skin =  """
1487                 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1488                         <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1489
1490                         <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1491                         <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1492
1493                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1494                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1495                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1496                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1497
1498                         <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" />
1499                         <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" />
1500                         <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" />
1501                         <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" />
1502                 </screen>
1503                 """
1504
1505         def __init__(self, _session, _url=None, _title=None):
1506                 self.mUrl   = _url
1507                 self.mTitle = _title
1508                 self.mBookmarkManager = BookmarkManager.getInstance()
1509                 self.mSession = _session
1510                 Screen.__init__(self, _session)
1511                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1512                                 "ok"    : self.keyOK,
1513                                 "cancel": self.keyCancel,
1514                                 "red"   : self.keyRed,
1515                                 "green" : self.keyGreen,
1516                                 "yellow": self.keyYellow,
1517                                 "blue"  : self.keyBlue,
1518                                 "0"     : self.keyNumber,
1519                         },-2)
1520
1521                 self["key_red"]    = StaticText(_("Exit"))
1522                 self["key_green"]  = StaticText(_("Add"))
1523                 self["key_yellow"] = StaticText(_("Edit"))
1524                 self["key_blue"]   = StaticText(_("Delete"))
1525                 self["key_0"]      = StaticText(_("Set as Startpage"))
1526
1527                 self.mBookmarkList = self.setBookmarkList()
1528                 self["bookmarklist"] = MenuList(self.mBookmarkList)
1529
1530                 self.onLayoutFinish.append(self.layoutFinished)
1531
1532         def layoutFinished(self):
1533                 self.setTitle(_('Bookmark'))
1534
1535         def setBookmarkList(self):
1536                 l = []
1537                 #self.mBookmarkManager.dump()
1538                 cd = self.mBookmarkManager.getBookmarkRoot()
1539                 for ck in cd.iterkeys():
1540                         l.append(('# ' + cd[ck].mName, cd[ck]))
1541                         bd = cd[ck].mBookmarks
1542                         for bk in bd.iterkeys():
1543                                 l.append(('    - ' + bd[bk].mTitle, bd[bk]))
1544                 return l
1545         def updateBookmarkList(self):
1546                 self.mBookmarkList = self.setBookmarkList()
1547                 self["bookmarklist"].setList(self.mBookmarkList)
1548         def cbEditWindow(self, ret=False):
1549                 if not ret:
1550                         return
1551                 self.updateBookmarkList()
1552         def getParentCategory(self):
1553                 idx = self["bookmarklist"].getSelectedIndex()
1554                 try:
1555                         while idx >= 0:
1556                                 data = self.mBookmarkList[idx][0].strip()
1557                                 if data[0] == '#':
1558                                         return self.mBookmarkList[idx][1]
1559                                 idx -= 1
1560                 except: pass
1561                 return None
1562         def isCategoryItem(self):
1563                 try:
1564                         head = self["bookmarklist"].getCurrent()[0].strip()
1565                         if head[0] == '#':
1566                                 return True
1567                 except: pass
1568                 return False
1569         def keyNumber(self):
1570                 data = self["bookmarklist"].getCurrent()[1]
1571                 if strIsEmpty(data.mUrl):
1572                         msg = _("Invalid URL. Please check again!!")
1573                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1574                         return
1575                 def cbSetStartpage(ret=None):
1576                         if ret is None: return
1577                         if ret:
1578                                 data = self["bookmarklist"].getCurrent()[1]
1579                                 OperaBrowserSetting().setData(data.mUrl, data.mType)
1580                 msg = _("Do you want to set selected url to the Startpage?")
1581                 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1582
1583         def keyGreen(self):
1584                 def cbGreen(data):
1585                         if data is None:
1586                                 return
1587                         if data[1] == 1:
1588                                 parent = self.getParentCategory()
1589                                 if parent is None:
1590                                         return
1591                                 if strIsEmpty(self.mTitle):
1592                                         return
1593                                 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1594                                 if not retAdd:
1595                                         msg = _("Current page is already exist.")
1596                                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1597                                 self.cbEditWindow(True)
1598                         elif data[1] == 2:
1599                                 parent = self.getParentCategory()
1600                                 if parent is None:
1601                                         return
1602                                 b = BookmarkData(0, '', '', parent.mId, 0)
1603                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1604                         elif data[1] == 3:
1605                                 c = CategoryData(0, '')
1606                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1607                 if strIsEmpty(self.mUrl):
1608                         l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1609                 else:   l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1610                 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1611         def keyYellow(self):
1612                 data = self["bookmarklist"].getCurrent()[1]
1613                 if self.isCategoryItem():
1614                         self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1615                 else:   self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1616         def keyBlue(self):
1617                 def cbBlue(ret=None):
1618                         if not ret: return
1619                         data = self["bookmarklist"].getCurrent()[1]
1620                         if self.isCategoryItem():
1621                                 self.mBookmarkManager.deleteCategory(data.mId)
1622                         else:   self.mBookmarkManager.deleteBookmark(data.mId)
1623                         self.updateBookmarkList()
1624                 if self.isCategoryItem():
1625                         msg = _("Do you want to delete the category and the bookmarks?")
1626                 else:   msg = _("Do you want to delete the bookmark?")
1627                 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1628         def keyOK(self):
1629                 if self.isCategoryItem(): return
1630
1631                 data = self["bookmarklist"].getCurrent()[1]
1632                 url = data.mUrl.strip()
1633                 if len(url) == 0:
1634                         self.session.open(MessageBox, _("Can't open selected bookmark.\n   - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1635                         return
1636                 mode = data.mType
1637                 if mode:
1638                         lang = language.getLanguage()
1639                         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1640                                 url = '/usr/local/manual/ru_RU/main.html'
1641                         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1642                                 url = '/usr/local/manual/de_DE/main.html'
1643                 self.close((url, mode))
1644         def keyRed(self):
1645                 self.keyCancel()
1646         def keyCancel(self):
1647                 self.close()
1648
1649 class BrowserHelpWindow(Screen, HelpableScreen):
1650         MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1651         skin =  """
1652                 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1653                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1654                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1655                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1656                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1657
1658                         <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" />
1659                         <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" />
1660                         <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" />
1661                         <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" />
1662                 </screen>
1663                 """
1664         def __init__(self, session):
1665                 Screen.__init__(self, session)
1666                 HelpableScreen.__init__(self)
1667
1668                 self["key_red"]    = StaticText(_("Exit"))
1669                 self["key_green"]  = StaticText(_("Global"))
1670                 self["key_yellow"] = StaticText(_("Mouse"))
1671                 self["key_blue"]   = StaticText(_("Keyboard"))
1672
1673                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1674                                 "ok"    : self.keyRed,
1675                                 "cancel": self.keyRed,
1676                                 "red"   : self.keyRed,
1677                                 "green" : self.keyGreen,
1678                                 "yellow": self.keyYellow,
1679                                 "blue"  : self.keyBlue,
1680                         },-2)
1681
1682                 self.showHelpTimer = eTimer()
1683                 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1684                 self.showHelpTimer.start(500)
1685
1686                 self.onLayoutFinish.append(self.layoutFinished)
1687
1688         def layoutFinished(self):
1689                 self.setTitle(_('Browser Help'))
1690
1691         def cbShowHelpTimerClosed(self):
1692                 self.showHelpTimer.stop()
1693                 self.setHelpModeActions(self.MODE_GLOBAL)
1694
1695         def setHelpModeActions(self, _mode=0):
1696                 self.helpList = []
1697                 if _mode == self.MODE_GLOBAL:
1698                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1699                                 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1700                         })
1701                         self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1702                                 "menu" : (self.keyPass, _("Show the Menu window.")),
1703                         })
1704                         self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1705                                 "green"  : (self.keyPass, _("Enter Key")),
1706                                 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1707                                 "blue"   : (self.keyPass, _("Backspace Key")),
1708                         })
1709                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1710                                 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1711                         })
1712
1713                 elif _mode == self.MODE_MOUSE:
1714                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1715                                 "up"    : (self.keyPass, _("It will move the mouse pointer up.")),
1716                                 "down"  : (self.keyPass, _("It will move the mouse pointer down.")),
1717                                 "left"  : (self.keyPass, _("It will move the mouse pointer left.")),
1718                                 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1719                         })
1720                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1721                                 "ok" : (self.keyPass, _("Left Mouse Button")),
1722                         })
1723                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1724                                 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1725                                 "nextService" : (self.keyPass, _("Left Key")),
1726                                 "prevService" : (self.keyPass, _("Right Key")),
1727                         })
1728                 elif _mode == self.MODE_KEYBOARD:
1729                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1730                                 "up"    : (self.keyPass, _("Up Key")),
1731                                 "down"  : (self.keyPass, _("Down Key")),
1732                                 "left"  : (self.keyPass, _("Left Key")),
1733                                 "right" : (self.keyPass, _("Right Key")),
1734                         })
1735                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1736                                 "ok" : (self.keyPass, _("Enter Key")),
1737                         })
1738                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1739                                 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1740                                 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1741                                 "nextService" : (self.keyPass, _("Go to previous page.")),
1742                                 "prevService" : (self.keyPass, _("Go to next page.")),
1743                         })
1744
1745                 if _mode > 0:
1746                         self.showHelp()
1747
1748         def keyPass(self):
1749                 pass
1750
1751         def keyRed(self):
1752                 self.close()
1753         def keyGreen(self):
1754                 self.setHelpModeActions(self.MODE_GLOBAL)
1755         def keyYellow(self):
1756                 self.setHelpModeActions(self.MODE_MOUSE)
1757         def keyBlue(self):
1758                 self.setHelpModeActions(self.MODE_KEYBOARD)
1759
1760 class OperaBrowser(Screen):
1761         MENUBAR_ITEM_WIDTH  = 150
1762         MENUBAR_ITEM_HEIGHT = 30
1763         SUBMENULIST_WIDTH   = 200
1764         SUBMENULIST_HEIGHT  = 25
1765         SUBMENULIST_NEXT    = 2
1766
1767         # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1768         # menulist->size->x     : SUBMENULIST_WIDTH
1769         # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1770         # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1771         # submenulist->size->x  : SUBMENULIST_WIDTH
1772
1773         size = getDesktop(0).size()
1774         WIDTH  = int(size.width())
1775         HEIGHT = int(size.height())
1776         skin =  """
1777                 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1778                         <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1779                         <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1780                         <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1781                         <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1782                         <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1783                         <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1784                         <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1785                 </screen>
1786                 """ % { 'width'  :WIDTH,
1787                         'height' :HEIGHT,
1788                         'bottom_pos_y'  :HEIGHT-80,
1789                         'bottom_size_x' :WIDTH }
1790
1791         COMMAND_MAP = {}
1792         MENUITEMS_LIST =[]
1793         def __init__(self, session, url=None):
1794                 Screen.__init__(self, session)
1795                 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1796                          "cancel"      : self.keyCancel
1797                         ,"ok"          : self.keyOK
1798                         ,"left"        : self.keyLeft
1799                         ,"right"       : self.keyRight
1800                         ,"up"          : self.keyUp
1801                         ,"down"        : self.keyDown
1802                         ,"menu"        : self.keyMenu
1803                 }, -2)
1804
1805                 self.UpdateLanguageCB()
1806
1807                 self._terminatedBrowser = True
1808                 self._enableKeyEvent = True
1809                 self._currentPageUrl = None
1810                 self._currentPageTitle = None
1811                 self.menubarCurrentIndex = 0
1812                 self.lvMenuItems = []
1813                 self.lvSubMenuItems = []
1814
1815                 self["topArea"]    = Label()
1816                 self["bottomArea"] = Label()
1817
1818                 self["menuitemFile"] = MultiColorLabel()# modify menu
1819                 self["menuitemTool"] = MultiColorLabel()
1820                 self["menuitemHelp"] = MultiColorLabel()
1821
1822                 self["menulist"] = MenuList(self.setListOnView())
1823                 self["submenulist"] = MenuList(self.setSubListOnView())
1824
1825                 self.toggleMainScreenFlag = True
1826                 self.toggleListViewFlag = False
1827                 self.toggleSubListViewFlag = False
1828                 self.currentListView = self["menulist"]
1829
1830                 self.onLayoutFinish.append(self.layoutFinished)
1831
1832                 self._onCloseTimer = eTimer()
1833                 self._onCloseTimer.callback.append(self._cb_onClose)
1834
1835                 self.paramUrl = url
1836                 language.addCallback(self.UpdateLanguageCB)
1837
1838         def UpdateLanguageCB(self):
1839                 # modify menu
1840                 self.MENUITEMS_LIST = [
1841                         [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1842                         [(_('Bookmark'), None), (_('Preference'), None)],
1843                         [(_('About'), None), (_('Help'), None)]]
1844                 self.COMMAND_MAP = {}
1845                 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1846                 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1847                 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1848                 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1849                 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1850                 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1851                 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1852                 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1853                 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1854
1855         def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1856                 rcmouse_path = "/proc/stb/fp/mouse"
1857                 if os.path.exists(rcmouse_path):
1858                         os.system("echo %d > %s" % (mode, rcmouse_path))
1859
1860         def layoutFinished(self):
1861                 self["menuitemFile"].setText(_("File"))# modify menu
1862                 self["menuitemTool"].setText(_("Tools"))
1863                 self["menuitemHelp"].setText(_("Help"))
1864
1865                 self["menulist"].hide()
1866                 self["submenulist"].hide()
1867
1868                 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1869                 self.setTitle(_("BrowserMain"))
1870                 self.selectMenuitem()
1871
1872                 if self.paramUrl is not None:
1873                         self.keyMenu()
1874                         self.cbUrlText(self.paramUrl, 1)
1875
1876         def selectMenuitem(self):
1877                 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1878                 self["menuitemFile"].setForegroundColorNum(0)
1879                 self["menuitemTool"].setForegroundColorNum(0)
1880                 self["menuitemHelp"].setForegroundColorNum(0)
1881                 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1882
1883         def popupCloseAll(self):
1884                 self.keyLeft()
1885                 self.keyLeft()
1886                 self.keyUp()
1887                 self.keyCancel()
1888
1889         def setListOnView(self):
1890                 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1891                 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1892                         l = [(_('Return'), None)]
1893                 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1894                 return self.lvMenuItems
1895
1896         def setSubListOnView(self):
1897                 self.lvSubMenuItems = []
1898                 xl = self["menulist"].getCurrent()[1]
1899                 if xl is None: return []
1900                 for x in xl:
1901                         self.lvSubMenuItems.append((x,None))
1902                 return self.lvSubMenuItems
1903
1904         def toggleMainScreen(self):
1905                 if not self.toggleMainScreenFlag:
1906                         self.show()
1907                 else:   self.hide()
1908                 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1909
1910         def toggleListView(self):
1911                 if not self.toggleListViewFlag:
1912                         self["menulist"].show()
1913                 else:   self["menulist"].hide()
1914                 self.toggleListViewFlag = not self.toggleListViewFlag
1915
1916         def toggleSubListView(self):
1917                 if not self.toggleSubListViewFlag:
1918                         self["submenulist"].show()
1919                 else:   self["submenulist"].hide()
1920                 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1921
1922         def setCurrentListView(self, listViewIdx):
1923                 if listViewIdx == 0:
1924                         self.currentListView = None
1925                 elif listViewIdx == 1:
1926                         self.currentListView = self["menulist"]
1927                 elif listViewIdx == 2:
1928                         self.currentListView = self["submenulist"]
1929
1930         def _cb_onClose(self):
1931                 self._onCloseTimer.stop()
1932                 command_server = getCommandServer()
1933                 try:
1934                         if self._on_close_window in command_server.onHbbTVCloseCB:
1935                                         command_server.onHbbTVCloseCB.remove(self._on_close_window)
1936                 except Exception, ErrMsg: pass
1937                 try:
1938                         if self._on_setPageTitle in command_server.onSetPageTitleCB:
1939                                 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1940                 except Exception, ErrMsg: pass
1941                 self._on_setPageTitle(_('Opera Browser'))
1942                 self.enableRCMouse(False)
1943                 self.toggleMainScreen()
1944                 restoreResolution()
1945                 fbClass.getInstance().unlock()
1946                 eRCInput.getInstance().unlock()
1947                 self._terminatedBrowser = True
1948                 self._enableKeyEvent = True
1949                 #if not self.toggleListViewFlag:
1950                 #       self.keyDown()
1951
1952                 self._currentPageUrl = ''
1953                 if self.paramUrl is not None:
1954                         self.keyCancel()
1955                 else:
1956                         self.keyRight()
1957                         self.keyLeft()
1958
1959         def _on_setPageTitle(self, title=None):
1960                 print "Title :",title
1961                 if title is None:
1962                         return
1963                 self.setTitle(title)
1964
1965         def cbUrlText(self, data=None, mode=0):
1966                 global _g_helper
1967                 if not _g_helper._is_browser_running():
1968                         return
1969                 print "Inputed Url :", data, mode
1970                 if strIsEmpty(data):
1971                         return
1972                 #self.hideSubmenu()
1973                 command_server = getCommandServer()
1974                 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1975                                 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1976                 if self._on_close_window not in command_server.onHbbTVCloseCB:
1977                         command_server.onHbbTVCloseCB.append(self._on_close_window)
1978                 self.toggleMainScreen()
1979                 self.enableRCMouse(True)
1980
1981                 fbClass.getInstance().lock()
1982                 eRCInput.getInstance().lock()
1983
1984                 setResolution(1280, 720)
1985
1986                 command_util = getCommandUtil()
1987                 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1988                 self._terminatedBrowser = False
1989                 self._enableKeyEvent = False
1990
1991         def _on_close_window(self):
1992                 self._onCloseTimer.start(1000)
1993
1994         def _cb_bookmarkWindowClosed(self, data=None):
1995                 if data is None:
1996                         return
1997                 (url, mode) = data
1998                 global _g_helper
1999                 if not _g_helper._is_browser_running():
2000                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2001                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2002                         return
2003                 self.cbUrlText(url, mode)
2004
2005         def _cmd_on_OpenUrl(self):
2006                 global _g_helper
2007                 if not _g_helper._is_browser_running():
2008                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2009                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2010                         return
2011                 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2012         def _cmd_on_About(self):
2013                 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2014         def _cmd_on_Exit(self):
2015                 self.close()
2016         def _cb_cmdOnStartSTop(self):
2017                 self.keyMenu()
2018         def _cmd_on_StartStop(self):
2019                 global _g_helper
2020                 if _g_helper is None:
2021                         return
2022                 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2023
2024         def _cmd_on_Bookmark(self):
2025                 url = self._currentPageUrl
2026                 if url is None:
2027                         url = ''
2028                 title = self._currentPageTitle
2029                 if title is None:
2030                         title = ''
2031                 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2032         def _cmd_on_Preference(self):
2033                 url = self._currentPageUrl
2034                 if url is None:
2035                         url = ''
2036                 self.session.open(OperaBrowserPreferenceWindow, url)
2037         def _cmd_on_OpenStartpage(self):
2038                 global _g_helper
2039                 if not _g_helper._is_browser_running():
2040                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2041                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2042                         return
2043                 mode = 0
2044                 start = 'http://vuplus.com'
2045                 try:
2046                         d = OperaBrowserSetting().getData()
2047                         start = d['start']
2048                         mode = d['type']
2049                 except: pass
2050                 self.cbUrlText(start, mode)
2051         def _cmd_on_ReturnToBrowser(self):
2052                 self.keyCancel()
2053
2054         def _cmd_on_Help(self):
2055                 self.session.open(BrowserHelpWindow)
2056
2057         def doCommand(self, command):
2058                 try:
2059                         self.COMMAND_MAP[command]()
2060                 except Exception, ErrMsg: print ErrMsg
2061
2062         def keyOK(self):
2063                 if not self.toggleMainScreenFlag:
2064                         self.keyMenu()
2065                         return
2066                 if not self.toggleListViewFlag:
2067                         self.keyDown()
2068                         return
2069                 if self.currentListView.getCurrent()[1] is None:
2070                         self.doCommand(self.currentListView.getCurrent()[0])
2071                         #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2072                         return
2073                 self.keyRight()
2074
2075         def updateSelectedMenuitem(self, status):
2076                 if self.menubarCurrentIndex == 0 and status < 0:
2077                         self.menubarCurrentIndex = 2 # modify menu
2078                 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2079                         self.menubarCurrentIndex = 0
2080                 else:   self.menubarCurrentIndex += status
2081                 self.selectMenuitem()
2082
2083         def keyLeft(self):
2084                 if not self.toggleMainScreenFlag:
2085                         return
2086                 if not self.toggleListViewFlag:
2087                         self.updateSelectedMenuitem(-1)
2088                         return
2089                 if self.toggleSubListViewFlag:
2090                         self.setCurrentListView(1)
2091                         self.toggleSubListView()
2092                         return
2093                 #if self.currentListView.getSelectedIndex():
2094                 self.currentListView.pageUp()
2095                 self.keyUp()
2096                 self.keyLeft()
2097                 self.keyDown()
2098
2099         def keyRight(self):
2100                 if not self.toggleMainScreenFlag:
2101                         return
2102                 if not self.toggleListViewFlag:
2103                         self.updateSelectedMenuitem(1)
2104                         return
2105                 if self.currentListView is None:
2106                         return
2107                 if self.currentListView.getCurrent()[1] is not None:
2108                         parentSelectedIndex = self.currentListView.getSelectedIndex()
2109                         self.setCurrentListView(2)
2110                         self.currentListView.setList(self.setSubListOnView())
2111                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2112                         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))
2113                         self.toggleSubListView()
2114                         return
2115                 self.currentListView.pageUp()
2116                 self.keyUp()
2117                 self.keyRight()
2118                 self.keyDown()
2119
2120         def keyDown(self):
2121                 if not self.toggleMainScreenFlag:
2122                         return
2123                 if self.currentListView is None:
2124                         return
2125                 if not self.toggleListViewFlag:
2126                         self.currentListView.setList(self.setListOnView())
2127                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2128                         self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2129                         self.toggleListView()
2130                         return
2131                 self.currentListView.down()
2132
2133         def keyUp(self):
2134                 if not self.toggleMainScreenFlag:
2135                         return
2136                 if self.currentListView is None:
2137                         return
2138                 if self.currentListView == self["menulist"]:
2139                         if self.currentListView.getSelectedIndex() == 0:
2140                                 self.toggleListView()
2141                                 return
2142                 self.currentListView.up()
2143
2144         def keyCancel(self):
2145                 if not self._terminatedBrowser:
2146                         #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2147                         fbClass.getInstance().lock()
2148                         eRCInput.getInstance().lock()
2149                         setResolution(1280, 720)
2150                         if self.toggleListViewFlag:
2151                                 self.toggleMainScreen()
2152                         self._currentPageUrl   = None
2153                         self._currentPageTitle = None
2154                         command_util = getCommandUtil()
2155                         command_util.sendCommand('OP_BROWSER_MENU_RES')
2156                         return
2157                 self.close()
2158
2159         def keyMenu(self):
2160                 self.toggleMainScreen()
2161
2162         def setCurrentPageUrl(self, url, title=None):
2163                 self._currentPageUrl = url
2164                 if title is None:
2165                         idx = len(url)
2166                         if idx > 10: idx = 10
2167                         title = url[:idx]
2168                 self._currentPageTitle = title
2169                 print self._currentPageUrl
2170                 self.toggleMainScreen()
2171                 self.hideSubmenu()
2172                 self.keyDown()
2173
2174         def hideSubmenu(self):
2175                 self.currentListView.pageUp()
2176                 self.keyUp()
2177
2178 def auto_start_main(reason, **kwargs):
2179         if reason:
2180                 command_server = getCommandServer()
2181                 command_server.stop()
2182
2183 from  Screens.HelpMenu import HelpableScreen
2184 def session_start_main(session, reason, **kwargs):
2185         fbClass.getInstance().unlock()
2186         eRCInput.getInstance().unlock()
2187
2188         from enigma import getDesktop
2189         desktopSize = getDesktop(0).size()
2190         setDefaultResolution(desktopSize.width(), desktopSize.height())
2191
2192         global _g_helper
2193         _g_helper = session.open(HbbTVHelper)
2194
2195         HelpableScreen.__init__ = HelpableScreen__init__
2196         HelpableScreen.session = session
2197
2198 def HelpableScreen__init__(self):
2199         if isinstance(self, HelpableScreen):
2200                 HelpableScreen.showManual = showManual
2201
2202                 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2203                         "help_b" : self.showHelp,
2204                         "help_l" : self.showManual,
2205                 }, -2)
2206
2207 _g_clearBrowserDataTimer = eTimer()
2208 def showManual(self):
2209         if not os.path.exists('/usr/local/manual'):
2210                 return
2211
2212         url = 'file:///usr/local/manual/main.html'
2213         lang = language.getLanguage()
2214         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2215                 url = 'file:///usr/local/manual/ru_RU/main.html'
2216         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2217                 url = 'file:///usr/local/manual/de_DE/main.html'
2218
2219         def _do_clean():
2220                 _g_clearBrowserDataTimer.stop()
2221                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2222                 except: pass
2223                 setPluginBrowser(None)
2224         def clearBrowserData():
2225                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2226                 _g_clearBrowserDataTimer.start(50)
2227         setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2228
2229 def plugin_start_main(session, **kwargs):
2230         #session.open(OperaBrowser)
2231         def _do_clean():
2232                 _g_clearBrowserDataTimer.stop()
2233                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2234                 except: pass
2235                 setPluginBrowser(None)
2236         def clearBrowserData():
2237                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2238                 _g_clearBrowserDataTimer.start(50)
2239         setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2240
2241 def plugin_extension_start_application(session, **kwargs):
2242         global _g_helper
2243         if _g_helper is None:
2244                 return
2245         _g_helper.showApplicationSelectionBox()
2246
2247 def plugin_extension_browser_config(session, **kwargs):
2248         global _g_helper
2249         if _g_helper is None:
2250                 return
2251         _g_helper.showBrowserConfigBox()
2252
2253 def Plugins(path, **kwargs):
2254         l = []
2255         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2256         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2257         l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2258         l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2259         l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))
2260
2261         return l
2262