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