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                         for u in self._applicationList:
1112                                 if u["control"] in (1, -1):
1113                                         url = u["url"]
1114                                         self._profile = u["profile"]
1115                 if url is None:
1116                         service = self._session.nav.getCurrentService()
1117                         info = service and service.info()
1118                         url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1119                 return url
1120
1121         def showApplicationSelectionBox(self):
1122                 applications = []
1123
1124                 if self.getStartHbbTVUrl():
1125                         for x in self._applicationList:
1126                                 applications.append((x["name"], x))
1127                 else: applications.append((_("No detected HbbTV applications."), None))
1128                 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1129
1130         def _application_selected(self, selected):
1131                 print selected
1132                 try:
1133                         if selected[1] is None: return
1134                         self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
1135                 except Exception, ErrMsg: print ErrMsg
1136
1137         def showBrowserConfigBox(self, callback=None):
1138                 start_stop_mode = []
1139                 self._callbackStartStop = callback
1140                 if self._is_browser_running():
1141                         start_stop_mode.append((_('Stop'),'Stop'))
1142                 else:   start_stop_mode.append((_('Start'),'Start'))
1143                 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1144
1145         def _browser_config_selected(self, selected):
1146                 if selected is None:
1147                         return
1148                 if self._callbackStartStop is not None:
1149                         self._callbackStartStop()
1150                 try:
1151                         mode = selected[1]
1152                         if mode == 'Start':
1153                                 if not self._is_browser_running():
1154                                         self._start_opera()
1155                         elif mode == 'Stop':
1156                                 self._stop_opera()
1157                 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1158
1159         def _is_browser_running(self):
1160                 try:
1161                         global HBBTVAPP_PATH
1162                         ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1163                         return ret.strip() != "0"
1164                 except Exception, ErrMsg:
1165                         print "Check Browser Running ERR :", ErrMsg
1166                 return False
1167
1168         def doChangeChannel(self, _sid, _tsid):
1169                 root = eServiceReference(service_types_tv)
1170                 if root is None:
1171                         return False
1172                 serviceList = eServiceCenter.getInstance().list(root)
1173                 if serviceList is None:
1174                         return False
1175                 while True:
1176                         service = serviceList.getNext()
1177                         if service is None or not service.valid():
1178                                 break
1179
1180                         #1:0:19:2840:3FB:1:C00000:0:0:0:
1181                         serviceRef = service.toString()
1182                         if strIsEmpty(serviceRef):
1183                                 continue
1184                         serviceRefItems = serviceRef.split(":")
1185                         if len(serviceRefItems) < 5:
1186                                 continue
1187
1188                         sid  = serviceRefItems[3]
1189                         tsid = serviceRefItems[4]
1190                         if sid == _sid and tsid == _tsid:
1191                                 self._session.nav.playService(eServiceReference(serviceRef))
1192                                 service = self._session.nav.getCurrentlyPlayingServiceReference()
1193                                 setBeforeService(service)
1194                                 return True
1195                 return False
1196
1197 class OperaBrowserSetting:
1198         def __init__(self):
1199                 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1200                 self._start = None
1201                 self._type  = None
1202                 self._keymap = None
1203                 self._read()
1204         def _read(self):
1205                 f = open(self._settingFileName)
1206                 for line in f.readlines():
1207                         if line.startswith('start='):
1208                                 tmp = line[6:len(line)-1].split()
1209                                 self._start = tmp[0]
1210                                 if len(tmp) > 1:
1211                                         self._type = int(tmp[1])
1212                                 else:   self._type = 0
1213                         elif line.startswith('keymap='):
1214                                 self._keymap = line[7:len(line)-1]
1215                 f.close()
1216         def _write(self):
1217                 tmpstr = []
1218                 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1219                 tmpstr.append('keymap=%s\n' % (self._keymap))
1220                 f = open(self._settingFileName, 'w')
1221                 f.writelines(tmpstr)
1222                 f.close()
1223         def setData(self, start, types=0, keymap="us-rc"):
1224                 self._start = start
1225                 self._type = types
1226                 self._keymap = keymap
1227                 self._write()
1228         def getData(self):
1229                 return {
1230                         'start':self._start,
1231                         'type':self._type,
1232                         'keymap':self._keymap,
1233                 }
1234
1235 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1236         skin=   """
1237                 <screen position="center,120" size="600,350" title="Preference">
1238                         <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1239                         <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1240
1241                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1242                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1243
1244                         <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" />
1245                         <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" />
1246                 </screen>
1247                 """
1248         def __init__(self, session, currentUrl):
1249                 self.session = session
1250                 Screen.__init__(self, session)
1251
1252                 self.menulist = []
1253                 ConfigListScreen.__init__(self, self.menulist)
1254
1255                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1256                         "red"    : self.keyRed,
1257                         "green"  : self.keyGreen,
1258                         "ok"     : self.keyOK,
1259                         "cancel" : self.keyRed
1260                 }, -2)
1261                 self["key_red"]   = StaticText(_("Cancel"))
1262                 self["key_green"] = StaticText(_("Save"))
1263                 self["url"]       = Label()
1264
1265                 self._currentPageUrl = currentUrl
1266                 if self._currentPageUrl is None:
1267                         self._currentPageUrl = ''
1268                 self._startPageUrl   = None
1269                 self._keymapType = None
1270                 self.makeMenuEntry()
1271                 self.onLayoutFinish.append(self.layoutFinished)
1272
1273         def layoutFinished(self):
1274                 self.setTitle(_('Preference'))
1275
1276         def updateStartPageUrl(self):
1277                 if self.menuItemStartpage.value == "startpage":
1278                         self["url"].setText(self._startPageUrl)
1279                 elif self.menuItemStartpage.value == "current":
1280                         self["url"].setText(self._currentPageUrl)
1281                 elif self.menuItemStartpage.value == "direct":
1282                         self["url"].setText('')
1283
1284         def keyGreen(self):
1285                 url = self["url"].getText()
1286                 if strIsEmpty(url):
1287                         self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1288                         return
1289                 mode = 0
1290                 if url.find('/usr/local/manual') > 0:
1291                         mode = 1
1292                 self._keymapType = self.menuItemKeyboardLayout.value
1293                 OperaBrowserSetting().setData(url, mode, self._keymapType)
1294                 command_util = getCommandUtil()
1295                 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1296                 self.close()
1297
1298         def keyRed(self):
1299                 self.close()
1300
1301         def keyOK(self):
1302                 def _cb_directInputUrl(data):
1303                         if strIsEmpty(data):
1304                                 return
1305                         self["url"].setText(data)
1306                 if self.menuItemStartpage.value == "direct":
1307                         self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1308
1309         def keyLeft(self):
1310                 ConfigListScreen.keyLeft(self)
1311                 self.updateStartPageUrl()
1312
1313         def keyRight(self):
1314                 ConfigListScreen.keyRight(self)
1315                 self.updateStartPageUrl()
1316
1317         def getKeymapTypeList(self):
1318                 types = []
1319                 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1320                         filesplit = f.split('.')
1321                         if len(filesplit) < 2:
1322                                 continue
1323                         types.append((filesplit[1], filesplit[1]))
1324                 types.sort()
1325                 return types
1326
1327         def makeMenuEntry(self):
1328                 l = []
1329                 l.append(("startpage", _("Start Page")))
1330                 if not strIsEmpty(self._currentPageUrl):
1331                         l.append(("current", _("Current Page")))
1332                 l.append(("direct", _("Direct Input")))
1333                 self.menuItemStartpage  = ConfigSelection(default="startpage", choices = l)
1334                 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1335
1336                 kl = self.getKeymapTypeList()
1337
1338                 try:
1339                         d = OperaBrowserSetting().getData()
1340                         self._startPageUrl = d['start']
1341                         self._keymapType = d['keymap']
1342                         #d['type']
1343                 except: self._startPageUrl = 'http://vuplus.com'
1344                 self.updateStartPageUrl()
1345
1346                 if self._keymapType is None or len(self._keymapType) == 0:
1347                         self._keymapType = "us-rc"
1348                 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1349                 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1350                 self.resetMenuList()
1351
1352         def resetMenuList(self):
1353                 self.menulist = []
1354                 self.menulist.append(self.menuEntryStartpage)
1355                 self.menulist.append(self.menuEntryKeyboardLayout)
1356
1357                 self["config"].list = self.menulist
1358                 self["config"].l.setList(self.menulist)
1359
1360 class BookmarkEditWindow(ConfigListScreen, Screen):
1361         CATEGORY,BOOKMARK = 0,1
1362         skin=   """
1363                 <screen position="center,center" size="600,140" title="Bookmark Edit">
1364                         <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1365
1366                         <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1367                         <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1368
1369                         <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" />
1370                         <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" />
1371
1372                         <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1373
1374                 </screen>
1375                 """
1376         def __init__(self, session, _mode, _type, _data, _bm):
1377                 self.mMode = _mode
1378                 self.mType = _type
1379                 self.mData = _data
1380                 self.mSession = session
1381                 self.mBookmarkManager = _bm
1382
1383                 if _data is not None:
1384                         print _data.mId
1385
1386                 Screen.__init__(self, session)
1387
1388                 self.menulist = []
1389                 ConfigListScreen.__init__(self, self.menulist)
1390
1391                 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1392                         "ok"     : self.keyGreen,
1393                         "green"  : self.keyGreen,
1394                         "red"    : self.keyRed,
1395                         "cancel" : self.keyRed,
1396                 }, -2)
1397
1398                 self["VKeyIcon"]  = Pixmap()
1399                 self["key_red"]   = StaticText(_("Cancel"))
1400                 self["key_green"] = StaticText(_("Save"))
1401
1402                 self.menuItemTitle = None
1403                 self.menuItemUrl   = None
1404                 self.menuItemName  = None
1405
1406                 self.menuEntryName = None
1407                 self.menuEntryTitle = None
1408                 self.menuEntryUrl = None
1409
1410                 self.makeConfigList()
1411                 self.onLayoutFinish.append(self.layoutFinished)
1412
1413         def layoutFinished(self):
1414                 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1415
1416         def selectedItem(self):
1417                 currentPosition = self["config"].getCurrent()
1418                 if self.mType == BookmarkEditWindow.CATEGORY:
1419                         return (_("Name"), self.menuItemName)
1420                 else:
1421                         if currentPosition == self.menuEntryTitle:
1422                                 return (_("Title"), self.menuItemTitle)
1423                         elif currentPosition == self.menuEntryUrl:
1424                                 return (_("Url"), self.menuItemUrl)
1425                 return None
1426
1427         def showMessageBox(self, text):
1428                 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1429                 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1430                 return False
1431
1432         def showVKeyWindow(self, data=None):
1433                 itemTitle = ""
1434                 itemValue = ""
1435                 selected = self.selectedItem()
1436                 if selected is not None:
1437                         itemValue = selected[1].value
1438                         if strIsEmpty(itemValue):
1439                                 itemValue = ""
1440                         itemTitle = selected[0]
1441
1442                 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1443
1444         def cbVKeyWindow(self, data=None):
1445                 if data is not None:
1446                         selected = self.selectedItem()
1447                         if selected is not None:
1448                                 selected[1].setValue(data)
1449
1450         def saveData(self):
1451                 if self.mType == BookmarkEditWindow.CATEGORY:
1452                         if self.mMode == _('Add'):
1453                                 categoryName = self.menuItemName.value
1454                                 if strIsEmpty(categoryName):
1455                                         return self.showMessageBox(_("Category Name"))
1456                                 self.mBookmarkManager.addCategory(categoryName)
1457                         else:
1458                                 if strIsEmpty(self.menuItemName.value):
1459                                         return self.showMessageBox(_("Category Name"))
1460                                 self.mData.mName = self.menuItemName.value
1461                                 self.mBookmarkManager.updateCategory(self.mData)
1462                 else:
1463                         if self.mMode == _('Add'):
1464                                 bookmarkTitle = self.menuItemTitle.value
1465                                 bookmarkUrl   = self.menuItemUrl.value
1466                                 if strIsEmpty(bookmarkTitle):
1467                                         self["config"].setCurrentIndex(0)
1468                                         return self.showMessageBox(_("Bookmark Title"))
1469                                 if strIsEmpty(bookmarkUrl):
1470                                         self["config"].setCurrentIndex(1)
1471                                         return self.showMessageBox(_("Bookmark URL"))
1472                                 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1473                         else:
1474                                 if strIsEmpty(self.menuItemTitle.value):
1475                                         self["config"].setCurrentIndex(0)
1476                                         return self.showMessageBox(_("Bookmark Title"))
1477                                 if strIsEmpty(self.menuItemUrl.value):
1478                                         self["config"].setCurrentIndex(1)
1479                                         return self.showMessageBox(_("Bookmark URL"))
1480                                 self.mData.mTitle = self.menuItemTitle.value
1481                                 self.mData.mUrl   = self.menuItemUrl.value
1482                                 self.mBookmarkManager.updateBookmark(self.mData)
1483                 return True
1484
1485         def keyGreen(self):
1486                 if not self.saveData():
1487                         return
1488                 self.close(True)
1489         def keyRed(self):
1490                 self.close(False)
1491         def keyLeft(self):
1492                 ConfigListScreen.keyLeft(self)
1493         def keyRight(self):
1494                 ConfigListScreen.keyRight(self)
1495         def makeConfigList(self):
1496                 self.menulist = []
1497
1498                 if self.mType == BookmarkEditWindow.CATEGORY:
1499                         self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1500
1501                         self.menuEntryName  = getConfigListEntry(_("Name"), self.menuItemName)
1502
1503                         self.menulist.append(self.menuEntryName)
1504                 else:
1505                         self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1506                         self.menuItemUrl   = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1507
1508                         self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1509                         self.menuEntryUrl   = getConfigListEntry(_("Url"), self.menuItemUrl)
1510
1511                         self.menulist.append(self.menuEntryTitle)
1512                         self.menulist.append(self.menuEntryUrl)
1513
1514                 self["config"].list = self.menulist
1515                 self["config"].l.setList(self.menulist)
1516
1517 class OperaBrowserBookmarkWindow(Screen):
1518         skin =  """
1519                 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1520                         <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1521
1522                         <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1523                         <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1524
1525                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1526                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1527                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1528                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1529
1530                         <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" />
1531                         <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" />
1532                         <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" />
1533                         <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" />
1534                 </screen>
1535                 """
1536
1537         def __init__(self, _session, _url=None, _title=None):
1538                 self.mUrl   = _url
1539                 self.mTitle = _title
1540                 self.mBookmarkManager = BookmarkManager.getInstance()
1541                 self.mSession = _session
1542                 Screen.__init__(self, _session)
1543                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1544                                 "ok"    : self.keyOK,
1545                                 "cancel": self.keyCancel,
1546                                 "red"   : self.keyRed,
1547                                 "green" : self.keyGreen,
1548                                 "yellow": self.keyYellow,
1549                                 "blue"  : self.keyBlue,
1550                                 "0"     : self.keyNumber,
1551                         },-2)
1552
1553                 self["key_red"]    = StaticText(_("Exit"))
1554                 self["key_green"]  = StaticText(_("Add"))
1555                 self["key_yellow"] = StaticText(_("Edit"))
1556                 self["key_blue"]   = StaticText(_("Delete"))
1557                 self["key_0"]      = StaticText(_("Set as Startpage"))
1558
1559                 self.mBookmarkList = self.setBookmarkList()
1560                 self["bookmarklist"] = MenuList(self.mBookmarkList)
1561
1562                 self.onLayoutFinish.append(self.layoutFinished)
1563
1564         def layoutFinished(self):
1565                 self.setTitle(_('Bookmark'))
1566
1567         def setBookmarkList(self):
1568                 l = []
1569                 #self.mBookmarkManager.dump()
1570                 cd = self.mBookmarkManager.getBookmarkRoot()
1571                 for ck in cd.iterkeys():
1572                         l.append(('# ' + cd[ck].mName, cd[ck]))
1573                         bd = cd[ck].mBookmarks
1574                         for bk in bd.iterkeys():
1575                                 l.append(('    - ' + bd[bk].mTitle, bd[bk]))
1576                 return l
1577         def updateBookmarkList(self):
1578                 self.mBookmarkList = self.setBookmarkList()
1579                 self["bookmarklist"].setList(self.mBookmarkList)
1580         def cbEditWindow(self, ret=False):
1581                 if not ret:
1582                         return
1583                 self.updateBookmarkList()
1584         def getParentCategory(self):
1585                 idx = self["bookmarklist"].getSelectedIndex()
1586                 try:
1587                         while idx >= 0:
1588                                 data = self.mBookmarkList[idx][0].strip()
1589                                 if data[0] == '#':
1590                                         return self.mBookmarkList[idx][1]
1591                                 idx -= 1
1592                 except: pass
1593                 return None
1594         def isCategoryItem(self):
1595                 try:
1596                         head = self["bookmarklist"].getCurrent()[0].strip()
1597                         if head[0] == '#':
1598                                 return True
1599                 except: pass
1600                 return False
1601         def keyNumber(self):
1602                 data = self["bookmarklist"].getCurrent()[1]
1603                 if strIsEmpty(data.mUrl):
1604                         msg = _("Invalid URL. Please check again!!")
1605                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1606                         return
1607                 def cbSetStartpage(ret=None):
1608                         if ret is None: return
1609                         if ret:
1610                                 data = self["bookmarklist"].getCurrent()[1]
1611                                 OperaBrowserSetting().setData(data.mUrl, data.mType)
1612                 msg = _("Do you want to set selected url to the Startpage?")
1613                 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1614
1615         def keyGreen(self):
1616                 def cbGreen(data):
1617                         if data is None:
1618                                 return
1619                         if data[1] == 1:
1620                                 parent = self.getParentCategory()
1621                                 if parent is None:
1622                                         return
1623                                 if strIsEmpty(self.mTitle):
1624                                         return
1625                                 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1626                                 if not retAdd:
1627                                         msg = _("Current page is already exist.")
1628                                         self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1629                                 self.cbEditWindow(True)
1630                         elif data[1] == 2:
1631                                 parent = self.getParentCategory()
1632                                 if parent is None:
1633                                         return
1634                                 b = BookmarkData(0, '', '', parent.mId, 0)
1635                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1636                         elif data[1] == 3:
1637                                 c = CategoryData(0, '')
1638                                 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1639                 if strIsEmpty(self.mUrl):
1640                         l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1641                 else:   l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1642                 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1643         def keyYellow(self):
1644                 data = self["bookmarklist"].getCurrent()[1]
1645                 if self.isCategoryItem():
1646                         self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1647                 else:   self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1648         def keyBlue(self):
1649                 def cbBlue(ret=None):
1650                         if not ret: return
1651                         data = self["bookmarklist"].getCurrent()[1]
1652                         if self.isCategoryItem():
1653                                 self.mBookmarkManager.deleteCategory(data.mId)
1654                         else:   self.mBookmarkManager.deleteBookmark(data.mId)
1655                         self.updateBookmarkList()
1656                 if self.isCategoryItem():
1657                         msg = _("Do you want to delete the category and the bookmarks?")
1658                 else:   msg = _("Do you want to delete the bookmark?")
1659                 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1660         def keyOK(self):
1661                 if self.isCategoryItem(): return
1662
1663                 data = self["bookmarklist"].getCurrent()[1]
1664                 url = data.mUrl.strip()
1665                 if len(url) == 0:
1666                         self.session.open(MessageBox, _("Can't open selected bookmark.\n   - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1667                         return
1668                 mode = data.mType
1669                 if mode:
1670                         lang = language.getLanguage()
1671                         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1672                                 url = '/usr/local/manual/ru_RU/main.html'
1673                         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1674                                 url = '/usr/local/manual/de_DE/main.html'
1675                 self.close((url, mode))
1676         def keyRed(self):
1677                 self.keyCancel()
1678         def keyCancel(self):
1679                 self.close()
1680
1681 class BrowserHelpWindow(Screen, HelpableScreen):
1682         MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1683         skin =  """
1684                 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1685                         <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1686                         <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1687                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1688                         <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1689
1690                         <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" />
1691                         <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" />
1692                         <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" />
1693                         <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" />
1694                 </screen>
1695                 """
1696         def __init__(self, session):
1697                 Screen.__init__(self, session)
1698                 HelpableScreen.__init__(self)
1699
1700                 self["key_red"]    = StaticText(_("Exit"))
1701                 self["key_green"]  = StaticText(_("Global"))
1702                 self["key_yellow"] = StaticText(_("Mouse"))
1703                 self["key_blue"]   = StaticText(_("Keyboard"))
1704
1705                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1706                                 "ok"    : self.keyRed,
1707                                 "cancel": self.keyRed,
1708                                 "red"   : self.keyRed,
1709                                 "green" : self.keyGreen,
1710                                 "yellow": self.keyYellow,
1711                                 "blue"  : self.keyBlue,
1712                         },-2)
1713
1714                 self.showHelpTimer = eTimer()
1715                 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1716                 self.showHelpTimer.start(500)
1717
1718                 self.onLayoutFinish.append(self.layoutFinished)
1719
1720         def layoutFinished(self):
1721                 self.setTitle(_('Browser Help'))
1722
1723         def cbShowHelpTimerClosed(self):
1724                 self.showHelpTimer.stop()
1725                 self.setHelpModeActions(self.MODE_GLOBAL)
1726
1727         def setHelpModeActions(self, _mode=0):
1728                 self.helpList = []
1729                 if _mode == self.MODE_GLOBAL:
1730                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1731                                 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1732                         })
1733                         self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1734                                 "menu" : (self.keyPass, _("Show the Menu window.")),
1735                         })
1736                         self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1737                                 "green"  : (self.keyPass, _("Enter Key")),
1738                                 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1739                                 "blue"   : (self.keyPass, _("Backspace Key")),
1740                         })
1741                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1742                                 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1743                         })
1744
1745                 elif _mode == self.MODE_MOUSE:
1746                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1747                                 "up"    : (self.keyPass, _("It will move the mouse pointer up.")),
1748                                 "down"  : (self.keyPass, _("It will move the mouse pointer down.")),
1749                                 "left"  : (self.keyPass, _("It will move the mouse pointer left.")),
1750                                 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1751                         })
1752                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1753                                 "ok" : (self.keyPass, _("Left Mouse Button")),
1754                         })
1755                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1756                                 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1757                                 "nextService" : (self.keyPass, _("Left Key")),
1758                                 "prevService" : (self.keyPass, _("Right Key")),
1759                         })
1760                 elif _mode == self.MODE_KEYBOARD:
1761                         self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1762                                 "up"    : (self.keyPass, _("Up Key")),
1763                                 "down"  : (self.keyPass, _("Down Key")),
1764                                 "left"  : (self.keyPass, _("Left Key")),
1765                                 "right" : (self.keyPass, _("Right Key")),
1766                         })
1767                         self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1768                                 "ok" : (self.keyPass, _("Enter Key")),
1769                         })
1770                         self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1771                                 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1772                                 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1773                                 "nextService" : (self.keyPass, _("Go to previous page.")),
1774                                 "prevService" : (self.keyPass, _("Go to next page.")),
1775                         })
1776
1777                 if _mode > 0:
1778                         self.showHelp()
1779
1780         def keyPass(self):
1781                 pass
1782
1783         def keyRed(self):
1784                 self.close()
1785         def keyGreen(self):
1786                 self.setHelpModeActions(self.MODE_GLOBAL)
1787         def keyYellow(self):
1788                 self.setHelpModeActions(self.MODE_MOUSE)
1789         def keyBlue(self):
1790                 self.setHelpModeActions(self.MODE_KEYBOARD)
1791
1792 class OperaBrowser(Screen):
1793         MENUBAR_ITEM_WIDTH  = 150
1794         MENUBAR_ITEM_HEIGHT = 30
1795         SUBMENULIST_WIDTH   = 200
1796         SUBMENULIST_HEIGHT  = 25
1797         SUBMENULIST_NEXT    = 2
1798
1799         # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1800         # menulist->size->x     : SUBMENULIST_WIDTH
1801         # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1802         # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1803         # submenulist->size->x  : SUBMENULIST_WIDTH
1804
1805         size = getDesktop(0).size()
1806         WIDTH  = int(size.width())
1807         HEIGHT = int(size.height())
1808         skin =  """
1809                 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1810                         <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1811                         <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1812                         <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1813                         <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1814                         <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1815                         <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1816                         <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1817                 </screen>
1818                 """ % { 'width'  :WIDTH,
1819                         'height' :HEIGHT,
1820                         'bottom_pos_y'  :HEIGHT-80,
1821                         'bottom_size_x' :WIDTH }
1822
1823         COMMAND_MAP = {}
1824         MENUITEMS_LIST =[]
1825         def __init__(self, session, url=None, isWebAppMode=False):
1826                 Screen.__init__(self, session)
1827                 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1828                          "cancel"      : self.keyCancel
1829                         ,"ok"          : self.keyOK
1830                         ,"left"        : self.keyLeft
1831                         ,"right"       : self.keyRight
1832                         ,"up"          : self.keyUp
1833                         ,"down"        : self.keyDown
1834                         ,"menu"        : self.keyMenu
1835                 }, -2)
1836
1837                 self.UpdateLanguageCB()
1838
1839                 self._terminatedBrowser = True
1840                 self._enableKeyEvent = True
1841                 self._currentPageUrl = None
1842                 self._currentPageTitle = None
1843                 self.menubarCurrentIndex = 0
1844                 self.lvMenuItems = []
1845                 self.lvSubMenuItems = []
1846
1847                 self["topArea"]    = Label()
1848                 self["bottomArea"] = Label()
1849
1850                 self["menuitemFile"] = MultiColorLabel()# modify menu
1851                 self["menuitemTool"] = MultiColorLabel()
1852                 self["menuitemHelp"] = MultiColorLabel()
1853
1854                 self["menulist"] = MenuList(self.setListOnView())
1855                 self["submenulist"] = MenuList(self.setSubListOnView())
1856
1857                 self.toggleMainScreenFlag = True
1858                 self.toggleListViewFlag = False
1859                 self.toggleSubListViewFlag = False
1860                 self.currentListView = self["menulist"]
1861
1862                 self.onLayoutFinish.append(self.layoutFinished)
1863
1864                 self._onCloseTimer = eTimer()
1865                 self._onCloseTimer.callback.append(self._cb_onClose)
1866
1867                 self.paramUrl = url
1868                 self.paramIsWebAppMode = isWebAppMode
1869                 language.addCallback(self.UpdateLanguageCB)
1870
1871         def UpdateLanguageCB(self):
1872                 # modify menu
1873                 self.MENUITEMS_LIST = [
1874                         [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1875                         [(_('Bookmark'), None), (_('Preference'), None)],
1876                         [(_('About'), None), (_('Help'), None)]]
1877                 self.COMMAND_MAP = {}
1878                 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1879                 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1880                 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1881                 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1882                 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1883                 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1884                 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1885                 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1886                 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1887
1888         def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1889                 rcmouse_path = "/proc/stb/fp/mouse"
1890                 if os.path.exists(rcmouse_path):
1891                         os.system("echo %d > %s" % (mode, rcmouse_path))
1892
1893         def layoutFinished(self):
1894                 self["menuitemFile"].setText(_("File"))# modify menu
1895                 self["menuitemTool"].setText(_("Tools"))
1896                 self["menuitemHelp"].setText(_("Help"))
1897
1898                 self["menulist"].hide()
1899                 self["submenulist"].hide()
1900
1901                 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1902                 self.setTitle(_("BrowserMain"))
1903                 self.selectMenuitem()
1904
1905                 if self.paramUrl is not None:
1906                         self.keyMenu()
1907                         if self.paramIsWebAppMode:
1908                                 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1909                         else:   self.cbUrlText(data=self.paramUrl, mode=1)
1910
1911         def selectMenuitem(self):
1912                 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1913                 self["menuitemFile"].setForegroundColorNum(0)
1914                 self["menuitemTool"].setForegroundColorNum(0)
1915                 self["menuitemHelp"].setForegroundColorNum(0)
1916                 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1917
1918         def popupCloseAll(self):
1919                 self.keyLeft()
1920                 self.keyLeft()
1921                 self.keyUp()
1922                 self.keyCancel()
1923
1924         def setListOnView(self):
1925                 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1926                 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1927                         l = [(_('Return'), None)]
1928                 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1929                 return self.lvMenuItems
1930
1931         def setSubListOnView(self):
1932                 self.lvSubMenuItems = []
1933                 xl = self["menulist"].getCurrent()[1]
1934                 if xl is None: return []
1935                 for x in xl:
1936                         self.lvSubMenuItems.append((x,None))
1937                 return self.lvSubMenuItems
1938
1939         def toggleMainScreen(self):
1940                 if not self.toggleMainScreenFlag:
1941                         self.show()
1942                 else:   self.hide()
1943                 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1944
1945         def toggleListView(self):
1946                 if not self.toggleListViewFlag:
1947                         self["menulist"].show()
1948                 else:   self["menulist"].hide()
1949                 self.toggleListViewFlag = not self.toggleListViewFlag
1950
1951         def toggleSubListView(self):
1952                 if not self.toggleSubListViewFlag:
1953                         self["submenulist"].show()
1954                 else:   self["submenulist"].hide()
1955                 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1956
1957         def setCurrentListView(self, listViewIdx):
1958                 if listViewIdx == 0:
1959                         self.currentListView = None
1960                 elif listViewIdx == 1:
1961                         self.currentListView = self["menulist"]
1962                 elif listViewIdx == 2:
1963                         self.currentListView = self["submenulist"]
1964
1965         def _cb_onClose(self):
1966                 self._onCloseTimer.stop()
1967                 command_server = getCommandServer()
1968                 try:
1969                         if self._on_close_window in command_server.onHbbTVCloseCB:
1970                                         command_server.onHbbTVCloseCB.remove(self._on_close_window)
1971                 except Exception, ErrMsg: pass
1972                 try:
1973                         if self._on_setPageTitle in command_server.onSetPageTitleCB:
1974                                 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1975                 except Exception, ErrMsg: pass
1976                 self._on_setPageTitle(_('Opera Browser'))
1977                 self.enableRCMouse(False)
1978                 self.toggleMainScreen()
1979                 restoreResolution()
1980                 fbClass.getInstance().unlock()
1981                 eRCInput.getInstance().unlock()
1982                 self._terminatedBrowser = True
1983                 self._enableKeyEvent = True
1984                 #if not self.toggleListViewFlag:
1985                 #       self.keyDown()
1986
1987                 self._currentPageUrl = ''
1988                 if self.paramUrl is not None:
1989                         self.keyCancel()
1990                 else:
1991                         self.keyRight()
1992                         self.keyLeft()
1993
1994         def _on_setPageTitle(self, title=None):
1995                 print "Title :",title
1996                 if title is None:
1997                         return
1998                 self.setTitle(title)
1999
2000         def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
2001                 global _g_helper
2002                 if not _g_helper._is_browser_running():
2003                         return
2004                 print "Inputed Url :", data, mode
2005                 if strIsEmpty(data):
2006                         return
2007                 #self.hideSubmenu()
2008                 command_server = getCommandServer()
2009                 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
2010                                 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
2011                 if self._on_close_window not in command_server.onHbbTVCloseCB:
2012                         command_server.onHbbTVCloseCB.append(self._on_close_window)
2013                 self.toggleMainScreen()
2014                 self.enableRCMouse(True)
2015
2016                 fbClass.getInstance().lock()
2017                 eRCInput.getInstance().lock()
2018
2019                 #setResolution(1280, 720)
2020
2021                 command_util = getCommandUtil()
2022                 command_util.sendCommand(opcode, data, mode)
2023                 self._terminatedBrowser = False
2024                 self._enableKeyEvent = False
2025
2026                 global __gval__
2027                 __gval__.hbbtv_handelr._soft_volume = -1
2028
2029         def _on_close_window(self):
2030                 self._onCloseTimer.start(1000)
2031
2032         def _cb_bookmarkWindowClosed(self, data=None):
2033                 if data is None:
2034                         return
2035                 (url, mode) = data
2036                 global _g_helper
2037                 if not _g_helper._is_browser_running():
2038                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2039                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2040                         return
2041                 self.cbUrlText(url, mode)
2042
2043         def _cmd_on_OpenUrl(self):
2044                 global _g_helper
2045                 if not _g_helper._is_browser_running():
2046                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2047                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2048                         return
2049                 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2050         def _cmd_on_About(self):
2051                 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2052         def _cmd_on_Exit(self):
2053                 self.close()
2054         def _cb_cmdOnStartSTop(self):
2055                 self.keyMenu()
2056         def _cmd_on_StartStop(self):
2057                 global _g_helper
2058                 if _g_helper is None:
2059                         return
2060                 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2061
2062         def _cmd_on_Bookmark(self):
2063                 url = self._currentPageUrl
2064                 if url is None:
2065                         url = ''
2066                 title = self._currentPageTitle
2067                 if title is None:
2068                         title = ''
2069                 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2070         def _cmd_on_Preference(self):
2071                 url = self._currentPageUrl
2072                 if url is None:
2073                         url = ''
2074                 self.session.open(OperaBrowserPreferenceWindow, url)
2075         def _cmd_on_OpenStartpage(self):
2076                 global _g_helper
2077                 if not _g_helper._is_browser_running():
2078                         message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2079                         self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2080                         return
2081                 mode = 0
2082                 start = 'http://vuplus.com'
2083                 try:
2084                         d = OperaBrowserSetting().getData()
2085                         start = d['start']
2086                         mode = d['type']
2087                 except: pass
2088                 self.cbUrlText(start, mode)
2089         def _cmd_on_ReturnToBrowser(self):
2090                 self.keyCancel()
2091
2092         def _cmd_on_Help(self):
2093                 self.session.open(BrowserHelpWindow)
2094
2095         def doCommand(self, command):
2096                 try:
2097                         self.COMMAND_MAP[command]()
2098                 except Exception, ErrMsg: print ErrMsg
2099
2100         def keyOK(self):
2101                 if not self.toggleMainScreenFlag:
2102                         self.keyMenu()
2103                         return
2104                 if not self.toggleListViewFlag:
2105                         self.keyDown()
2106                         return
2107                 if self.currentListView.getCurrent()[1] is None:
2108                         self.doCommand(self.currentListView.getCurrent()[0])
2109                         #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2110                         return
2111                 self.keyRight()
2112
2113         def updateSelectedMenuitem(self, status):
2114                 if self.menubarCurrentIndex == 0 and status < 0:
2115                         self.menubarCurrentIndex = 2 # modify menu
2116                 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2117                         self.menubarCurrentIndex = 0
2118                 else:   self.menubarCurrentIndex += status
2119                 self.selectMenuitem()
2120
2121         def keyLeft(self):
2122                 if not self.toggleMainScreenFlag:
2123                         return
2124                 if not self.toggleListViewFlag:
2125                         self.updateSelectedMenuitem(-1)
2126                         return
2127                 if self.toggleSubListViewFlag:
2128                         self.setCurrentListView(1)
2129                         self.toggleSubListView()
2130                         return
2131                 #if self.currentListView.getSelectedIndex():
2132                 self.currentListView.pageUp()
2133                 self.keyUp()
2134                 self.keyLeft()
2135                 self.keyDown()
2136
2137         def keyRight(self):
2138                 if not self.toggleMainScreenFlag:
2139                         return
2140                 if not self.toggleListViewFlag:
2141                         self.updateSelectedMenuitem(1)
2142                         return
2143                 if self.currentListView is None:
2144                         return
2145                 if self.currentListView.getCurrent()[1] is not None:
2146                         parentSelectedIndex = self.currentListView.getSelectedIndex()
2147                         self.setCurrentListView(2)
2148                         self.currentListView.setList(self.setSubListOnView())
2149                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2150                         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))
2151                         self.toggleSubListView()
2152                         return
2153                 self.currentListView.pageUp()
2154                 self.keyUp()
2155                 self.keyRight()
2156                 self.keyDown()
2157
2158         def keyDown(self):
2159                 if not self.toggleMainScreenFlag:
2160                         return
2161                 if self.currentListView is None:
2162                         return
2163                 if not self.toggleListViewFlag:
2164                         self.currentListView.setList(self.setListOnView())
2165                         self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2166                         self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2167                         self.toggleListView()
2168                         return
2169                 self.currentListView.down()
2170
2171         def keyUp(self):
2172                 if not self.toggleMainScreenFlag:
2173                         return
2174                 if self.currentListView is None:
2175                         return
2176                 if self.currentListView == self["menulist"]:
2177                         if self.currentListView.getSelectedIndex() == 0:
2178                                 self.toggleListView()
2179                                 return
2180                 self.currentListView.up()
2181
2182         def keyCancel(self):
2183                 if not self._terminatedBrowser:
2184                         #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2185                         fbClass.getInstance().lock()
2186                         eRCInput.getInstance().lock()
2187                         #setResolution(1280, 720)
2188                         if self.toggleListViewFlag:
2189                                 self.toggleMainScreen()
2190                         self._currentPageUrl   = None
2191                         self._currentPageTitle = None
2192                         command_util = getCommandUtil()
2193                         command_util.sendCommand('OP_BROWSER_MENU_RES')
2194                         return
2195                 self.close()
2196
2197         def keyMenu(self):
2198                 self.toggleMainScreen()
2199
2200         def setCurrentPageUrl(self, url, title=None):
2201                 self._currentPageUrl = url
2202                 if title is None:
2203                         idx = len(url)
2204                         if idx > 10: idx = 10
2205                         title = url[:idx]
2206                 self._currentPageTitle = title
2207                 print self._currentPageUrl
2208                 self.toggleMainScreen()
2209                 self.hideSubmenu()
2210                 self.keyDown()
2211
2212         def hideSubmenu(self):
2213                 self.currentListView.pageUp()
2214                 self.keyUp()
2215
2216 config.plugins.youtubetv = ConfigSubsection()
2217 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2218 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2219 class YoutubeTVWindow(Screen, HelpableScreen):
2220         skin =  """
2221                 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2222                         <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2223                         <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2224                         <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2225                         <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2226                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2227                         <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" />
2228                         <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" />
2229                 </screen>
2230                 """
2231         def __init__(self, session):
2232                 Screen.__init__(self, session)
2233                 HelpableScreen.__init__(self)
2234
2235                 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2236                                 "cancel": self.keyCancel,
2237                                 "red"   : self.keyCancel,
2238                                 "green" : self.keyGreen,
2239                                 "yellow": self.keyYellow,
2240                         },-2)
2241
2242                 self["key_green"]  = StaticText(_("Start"))
2243                 self["key_yellow"] = StaticText(_("Help"))
2244
2245                 self["infomation"] = Label()
2246                 self["startdesc"]  = Label()
2247                 self["helpdesc"]   = Label()
2248
2249                 self.onLayoutFinish.append(self.layoutFinished)
2250
2251         def layoutFinished(self):
2252                 self.setTitle(_('Start YouTube TV'))
2253                 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2254                 self["startdesc" ].setText(_("* Start YouTube TV"))
2255                 self["helpdesc"  ].setText(_("* RC Help"))
2256
2257         def setHelpModeActions(self):
2258                 self.helpList = []
2259                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2260                         "ok"    : (self.keyPass, _("Play ther selected the video")),
2261                         "cancel": (self.keyPass, _("Exit the YouTube TV")),
2262                 })
2263                 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2264                         "pageUp"    : (self.keyPass, _("Move up")),
2265                         "pageDown"  : (self.keyPass, _("Move down")),
2266                         "prevEvent" : (self.keyPass, _("Move left")),
2267                         "nextEvent" : (self.keyPass, _("Move right")),
2268                 })
2269                 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2270                         "info"        : (self.keyPass, _("Search a video")),
2271                         "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2272                         "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2273                 })
2274                 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2275                         "play"  : (self.keyPass, _("Play current video")),
2276                         "pause" : (self.keyPass, _("Pause current video")),
2277                         "stop"  : (self.keyPass, _("Stop current video")),
2278                 })
2279                 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2280                         "red"   : (self.keyPass, _("Back")),
2281                 })
2282                 self.showHelp()
2283
2284         def keyPass(self):
2285                 pass
2286         def keyCancel(self):
2287                 config.plugins.youtubetv.showhelp.cancel()
2288                 self.close(False)
2289         def keyGreen(self):
2290                 config.plugins.youtubetv.showhelp.save()
2291                 config.plugins.youtubetv.save()
2292                 config.plugins.save()
2293                 self.close(True)
2294         def keyYellow(self):
2295                 self.setHelpModeActions()
2296         def keyBlue(self):
2297                 if config.plugins.youtubetv.showhelp.value == True :
2298                         config.plugins.youtubetv.showhelp.setValue(False)
2299                 else:   config.plugins.youtubetv.showhelp.setValue(True)
2300
2301 class YoutubeTVSettings(ConfigListScreen, Screen):
2302     skin=   """
2303         <screen position="center,center" size="600,140" title="YouTube TV Settings">
2304             <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2305
2306             <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2307             <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2308
2309             <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" />
2310             <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" />
2311         </screen>
2312         """
2313     def __init__(self, session):
2314         self.session = session
2315         Screen.__init__(self, session)
2316
2317         self.menulist = []
2318         ConfigListScreen.__init__(self, self.menulist)
2319
2320         self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2321             "ok"     : self.keyGreen,
2322             "green"  : self.keyGreen,
2323             "red"    : self.keyRed,
2324             "cancel" : self.keyRed,
2325                 }, -2)
2326
2327         self["key_red"]   = StaticText(_("Cancel"))
2328         self["key_green"] = StaticText(_("Save"))
2329
2330         self.makeConfigList()
2331         self.onLayoutFinish.append(self.layoutFinished)
2332
2333     def layoutFinished(self):
2334         self.setTitle(_('YouTube TV Settings'))
2335
2336     def keyGreen(self):
2337         config.plugins.youtubetv.showhelp.save()
2338         config.plugins.youtubetv.uri.save()
2339         config.plugins.youtubetv.save()
2340         config.plugins.save()
2341         self.close()
2342     def keyRed(self):
2343         config.plugins.youtubetv.showhelp.cancel()
2344         config.plugins.youtubetv.uri.cancel()
2345         self.close()
2346
2347     def keyLeft(self):
2348         ConfigListScreen.keyLeft(self)
2349
2350     def keyRight(self):
2351         ConfigListScreen.keyRight(self)
2352
2353     def makeConfigList(self):
2354         self.menulist = []
2355         entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2356         entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Stater again"), config.plugins.youtubetv.showhelp)
2357         self.menulist.append(entryUri)
2358         self.menulist.append(entryShowHelp)
2359
2360         self["config"].list = self.menulist
2361         self["config"].l.setList(self.menulist)
2362
2363 def auto_start_main(reason, **kwargs):
2364         if reason:
2365                 command_server = getCommandServer()
2366                 command_server.stop()
2367
2368 from  Screens.HelpMenu import HelpableScreen
2369 def session_start_main(session, reason, **kwargs):
2370         fbClass.getInstance().unlock()
2371         eRCInput.getInstance().unlock()
2372
2373         from enigma import getDesktop
2374         desktopSize = getDesktop(0).size()
2375         setDefaultResolution(desktopSize.width(), desktopSize.height())
2376
2377         global _g_helper
2378         _g_helper = session.open(HbbTVHelper)
2379
2380         HelpableScreen.__init__ = HelpableScreen__init__
2381         HelpableScreen.session = session
2382
2383 def HelpableScreen__init__(self):
2384         if isinstance(self, HelpableScreen):
2385                 HelpableScreen.showManual = showManual
2386
2387                 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2388                         "help_b" : self.showHelp,
2389                         "help_l" : self.showManual,
2390                 }, -2)
2391
2392 _g_clearBrowserDataTimer = eTimer()
2393 def showManual(self):
2394         if not os.path.exists('/usr/local/manual'):
2395                 return
2396
2397         url = 'file:///usr/local/manual/main.html'
2398         lang = language.getLanguage()
2399         if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2400                 url = 'file:///usr/local/manual/ru_RU/main.html'
2401         elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2402                 url = 'file:///usr/local/manual/de_DE/main.html'
2403
2404         def _do_clean():
2405                 _g_clearBrowserDataTimer.stop()
2406                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2407                 except: pass
2408                 setPluginBrowser(None)
2409         def clearBrowserData():
2410                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2411                 _g_clearBrowserDataTimer.start(50)
2412         setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2413
2414 _g_backupSession = None
2415 def showYoutubeTV(session, **kwargs):
2416         def _do_clean():
2417                 _g_clearBrowserDataTimer.stop()
2418                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2419                 except: pass
2420                 setPluginBrowser(None)
2421                 global _g_backupSession
2422
2423                 service = getBeforeService()
2424                 if service is not None:
2425                         _g_backupSession.nav.playService(eServiceReference(service))
2426                         _g_backupSession = None
2427         def clearBrowserData():
2428                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2429                 _g_clearBrowserDataTimer.start(50)
2430         def cbYoutubeTVClose(ret):
2431                 if ret:
2432                         global _g_backupSession
2433                         _g_backupSession = session
2434                         service = session.nav.getCurrentlyPlayingServiceReference()
2435                         if service is not None:
2436                                 setBeforeService(service.toString())
2437                                 session.nav.stopService()
2438                         else:   setBeforeService(service)
2439                         setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2440         if config.plugins.youtubetv.showhelp.value == True:
2441                 cbYoutubeTVClose(True)
2442         else:   session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2443
2444 def youtube_setting_main(session, **kwargs):
2445         session.open(YoutubeTVSettings)
2446
2447 def start_menu_main(menuid, **kwargs):
2448         if menuid == "mainmenu":
2449                 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2450         return []
2451
2452 def plugin_start_main(session, **kwargs):
2453         #session.open(OperaBrowser)
2454         def _do_clean():
2455                 _g_clearBrowserDataTimer.stop()
2456                 try:    _g_clearBrowserDataTimer.callback.remove(_do_clean)
2457                 except: pass
2458                 setPluginBrowser(None)
2459         def clearBrowserData():
2460                 _g_clearBrowserDataTimer.callback.append(_do_clean)
2461                 _g_clearBrowserDataTimer.start(50)
2462         setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2463
2464 def plugin_extension_start_application(session, **kwargs):
2465         global _g_helper
2466         if _g_helper is None:
2467                 return
2468         _g_helper.showApplicationSelectionBox()
2469
2470 def plugin_extension_browser_config(session, **kwargs):
2471         global _g_helper
2472         if _g_helper is None:
2473                 return
2474         _g_helper.showBrowserConfigBox()
2475
2476 def Plugins(path, **kwargs):
2477         l = []
2478         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2479         l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2480         l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2481         l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2482         l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2483         l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2484         l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))
2485
2486         return l
2487