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