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

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