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

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