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