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

   1 from Plugins.Plugin import PluginDescriptor
   2
   3 import time, os, socket, thread, socket, copy
   4 from socket import gaierror, error
   5 from os import path as os_path, remove as os_remove
   6
   7 import gdata.youtube
   8 import gdata.youtube.service
   9 from gdata.service import BadAuthentication
  10
  11 from twisted.web import client
  12 from twisted.internet import reactor
  13
  14 from urlparse import parse_qs
  15 from urllib import quote, unquote_plus, unquote
  16 from urllib2 import Request, URLError, urlopen as urlopen2
  17 from httplib import HTTPConnection, CannotSendRequest, BadStatusLine, HTTPException
  18
  19 from Components.Button import Button
  20 from Components.Label import Label
  21 from Components.Pixmap import Pixmap
  22 from Components.Language import language
  23 from Components.Sources.List import List
  24 from Components.ConfigList import ConfigListScreen
  25 from Components.Sources.StaticText import StaticText
  26 from Components.ActionMap import NumberActionMap, ActionMap
  27 from Components.ServiceEventTracker import ServiceEventTracker
  28 from Components.config import config, ConfigSelection, getConfigListEntry, ConfigSlider
  29
  30 from Screens.Screen import Screen
  31 from Screens.ChoiceBox import ChoiceBox
  32 from Screens.MessageBox import MessageBox
  33 from Screens.DefaultWizard import DefaultWizard
  34 from Screens.InfoBarGenerics import InfoBarNotifications
  35
  36 from enigma import eTimer, eServiceReference, iPlayableService, fbClass, eRCInput, eConsoleAppContainer, getDesktop
  37
  38 HTTPConnection.debuglevel = 1
  39
  40 def excute_cmd(cmd):
  41         print "prepared cmd:", cmd
  42         os.system(cmd)
  43
  44 alpha_value = 0
  45 def change_galpha(set_const, set_value):
  46         op  = "/proc/stb/fb/alpha_op"
  47         val = "/proc/stb/fb/alpha_value"
  48         global alpha_value
  49         if os.path.exists(op) and set_const and alpha_value < 255:
  50                 excute_cmd("echo \"const\" > %s" % (op))
  51         else:
  52                 excute_cmd("echo \"copypsrc\" > %s" % (op))
  53
  54         if os.path.exists(val) and set_value:
  55                 excute_cmd("echo \"%s\" > %s" % (str(hex(alpha_value)), val))
  56
  57 def enable_rc_mouse(mode): #mode=[0|1]|[False|True]
  58         mouse_cond = "/proc/stb/fp/mouse"
  59         if os.path.exists(mouse_cond):
  60                 excute_cmd("echo %d > %s" % (mode, mouse_cond))
  61
  62 def is_process_running(pname):
  63         if pname is None or len(pname) == 0:
  64                 return False
  65
  66         cmd = "/bin/ps -ef | grep %s | grep -v grep | awk \'{print $5}\'"%(pname)
  67         for line in os.popen(cmd).readlines():
  68                 return True
  69         return False
  70
  71 lock = False
  72 def wb_lock(alpha_on=True):
  73         global lock
  74         lock = True
  75         if alpha_on:
  76                 change_galpha(set_const=False, set_value=False)
  77         fbClass.getInstance().unlock()
  78
  79 def wb_unlock(alpha_on=True):
  80         global lock
  81         if alpha_on:
  82                 change_galpha(set_const=True, set_value=False)
  83         fbClass.getInstance().lock()
  84         lock = False
  85
  86 def wb_islock():
  87         global lock
  88         return lock
  89
  90 class VuPlayer(Screen, InfoBarNotifications):
  91         size = getDesktop(0).size()
  92         position_params = size.width() > 750 and (620) or (480)
  93         skin =  """
  94                 <screen name="VuPlayer" flags="wfNoBorder" position="center,%d" size="455,53" title="VuPlayer" backgroundColor="transparent">
  95                         <ePixmap pixmap="Vu_HD/mp_wb_background.png" position="0,0" zPosition="-1" size="455,53" />
  96                         <ePixmap pixmap="Vu_HD/icons/mp_wb_buttons.png" position="40,23" size="30,13" alphatest="on" />
  97
  98                         <widget source="session.CurrentService" render="PositionGauge" position="80,25" size="220,10" zPosition="2" pointer="skin_default/position_pointer.png:540,0" transparent="1" foregroundColor="#20224f">
  99                                 <convert type="ServicePosition">Gauge</convert>
 100                         </widget>
 101
 102                         <widget source="session.CurrentService" render="Label" position="310,20" size="50,20" font="Regular;18" halign="center" valign="center" backgroundColor="#4e5a74" transparent="1" >
 103                                 <convert type="ServicePosition">Position</convert>
 104                         </widget>
 105                         <widget name="sidebar" position="362,20" size="10,20" font="Regular;18" halign="center" valign="center" backgroundColor="#4e5a74" transparent="1" />
 106                         <widget source="session.CurrentService" render="Label" position="374,20" size="50,20" font="Regular;18" halign="center" valign="center" backgroundColor="#4e5a74" transparent="1" >
 107                                 <convert type="ServicePosition">Length</convert>
 108                         </widget>
 109                 </screen>
 110                 """ % position_params
 111
 112         PLAYER_IDLE     = 0
 113         PLAYER_PLAYING  = 1
 114         PLAYER_PAUSED   = 2
 115
 116         def __init__(self, session, service, lastservice):
 117                 Screen.__init__(self, session)
 118                 InfoBarNotifications.__init__(self)
 119
 120                 self.session     = session
 121                 self.service     = service
 122                 self.lastservice = lastservice
 123                 self["actions"] = ActionMap(["OkCancelActions", "InfobarSeekActions", "MediaPlayerActions", "MovieSelectionActions"],
 124                 {
 125                         "ok": self.doInfoAction,
 126                         "cancel": self.doExit,
 127                         "stop": self.doExit,
 128                         "playpauseService": self.playpauseService,
 129                 }, -2)
 130                 self["sidebar"] = Label(_("/"))
 131
 132                 self.__event_tracker = ServiceEventTracker(screen = self, eventmap =
 133                 {
 134                         iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
 135                         iPlayableService.evStart: self.__serviceStarted,
 136                         iPlayableService.evEOF: self.__evEOF,
 137                 })
 138
 139                 self.hidetimer = eTimer()
 140                 self.hidetimer.timeout.get().append(self.doInfoAction)
 141
 142                 self.state = self.PLAYER_PLAYING
 143                 self.lastseekstate = self.PLAYER_PLAYING
 144                 self.__seekableStatusChanged()
 145
 146                 self.onClose.append(self.__onClose)
 147                 self.doPlay()
 148
 149         def __onClose(self):
 150                 self.session.nav.stopService()
 151
 152         def __seekableStatusChanged(self):
 153                 service = self.session.nav.getCurrentService()
 154                 if service is not None:
 155                         seek = service.seek()
 156                         if seek is None or not seek.isCurrentlySeekable():
 157                                 self.setSeekState(self.PLAYER_PLAYING)
 158
 159         def __serviceStarted(self):
 160                 self.state = self.PLAYER_PLAYING
 161                 self.__seekableStatusChanged()
 162
 163         def __evEOF(self):
 164                 self.doExit()
 165
 166         def __setHideTimer(self):
 167                 self.hidetimer.start(5000)
 168
 169         def doExit(self):
 170                 list = ((_("Yes"), "y"), (_("No, but play video again"), "n"),)
 171                 self.session.openWithCallback(self.cbDoExit, ChoiceBox, title=_("Stop playing this movie?"), list = list)
 172
 173         def cbDoExit(self, answer):
 174                 answer = answer and answer[1]
 175                 if answer == "y":
 176                         wb_unlock()
 177                         self.close()
 178                 elif answer == "n":
 179                         if self.state != self.PLAYER_IDLE:
 180                                 self.session.nav.stopService()
 181                                 self.state = self.PLAYER_IDLE
 182                         self.doPlay()
 183
 184         def setSeekState(self, wantstate):
 185                 service = self.session.nav.getCurrentService()
 186                 if service is None:
 187                         print "No Service found"
 188                         return
 189
 190                 pauseable = service.pause()
 191                 if pauseable is not None:
 192                         if wantstate == self.PLAYER_PAUSED:
 193                                 pauseable.pause()
 194                                 self.state = self.PLAYER_PAUSED
 195                                 if not self.shown:
 196                                         self.hidetimer.stop()
 197                                         self.show()
 198                         elif wantstate == self.PLAYER_PLAYING:
 199                                 pauseable.unpause()
 200                                 self.state = self.PLAYER_PLAYING
 201                                 if self.shown:
 202                                         self.__setHideTimer()
 203                 else:
 204                         self.state = self.PLAYER_PLAYING
 205
 206         def doInfoAction(self):
 207                 if self.shown:
 208                         self.hide()
 209                         self.hidetimer.stop()
 210                 else:
 211                         self.show()
 212                         if self.state == self.PLAYER_PLAYING:
 213                                 self.__setHideTimer()
 214
 215         def doPlay(self):
 216                 if self.state == self.PLAYER_PAUSED:
 217                         if self.shown:
 218                                 self.__setHideTimer()
 219                 self.state = self.PLAYER_PLAYING
 220                 self.session.nav.playService(self.service)
 221                 if self.shown:
 222                         self.__setHideTimer()
 223
 224         def playpauseService(self):
 225                 if self.state == self.PLAYER_PLAYING:
 226                         self.setSeekState(self.PLAYER_PAUSED)
 227                 elif self.state == self.PLAYER_PAUSED:
 228                         self.setSeekState(self.PLAYER_PLAYING)
 229
 230 VIDEO_FMT_PRIORITY_MAP = {
 231         '38' : 1, #MP4 Original (HD)
 232         '37' : 2, #MP4 1080p (HD)
 233         '22' : 3, #MP4 720p (HD)
 234         '18' : 4, #MP4 360p
 235         '35' : 5, #FLV 480p
 236         '34' : 6, #FLV 360p
 237 }
 238 std_headers = {
 239         'User-Agent': 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.6) Gecko/20100627 Firefox/3.6.6',
 240         'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
 241         'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 242         'Accept-Language': 'en-us,en;q=0.5',
 243 }
 244
 245 class VuPlayerLauncher:
 246         def getVideoUrl(self, video_id):
 247                 video_url = None
 248
 249                 if video_id is None or video_id == "":
 250                         return video_url
 251
 252                 # Getting video webpage
 253                 watch_url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id
 254                 watchrequest = Request(watch_url, None, std_headers)
 255                 try:
 256                         #print "trying to find out if a HD Stream is available",watch_url
 257                         watchvideopage = urlopen2(watchrequest).read()
 258                 except (URLError, HTTPException, socket.error), err:
 259                         print "Error: Unable to retrieve watchpage - Error code: ", str(err)
 260                         return video_url
 261
 262                 # Get video info
 263                 for el in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
 264                         info_url = ('http://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en' % (video_id, el))
 265                         request = Request(info_url, None, std_headers)
 266                         try:
 267                                 infopage = urlopen2(request).read()
 268                                 videoinfo = parse_qs(infopage)
 269                                 if ('url_encoded_fmt_stream_map' or 'fmt_url_map') in videoinfo:
 270                                         break
 271                         except (URLError, HTTPException, socket.error), err:
 272                                 print "Error: unable to download video infopage",str(err)
 273                                 return video_url
 274
 275                 if ('url_encoded_fmt_stream_map' or 'fmt_url_map') not in videoinfo:
 276                         if 'reason' not in videoinfo:
 277                                 print 'Error: unable to extract "fmt_url_map" or "url_encoded_fmt_stream_map" parameter for unknown reason'
 278                         else:
 279                                 reason = unquote_plus(videoinfo['reason'][0])
 280                                 print 'Error: YouTube said: %s' % reason.decode('utf-8')
 281                         return video_url
 282
 283                 video_fmt_map = {}
 284                 fmt_infomap = {}
 285                 if videoinfo.has_key('url_encoded_fmt_stream_map'):
 286                         tmp_fmtUrlDATA = videoinfo['url_encoded_fmt_stream_map'][0].split(',url=')
 287                 else:
 288                         tmp_fmtUrlDATA = videoinfo['fmt_url_map'][0].split(',')
 289                 for fmtstring in tmp_fmtUrlDATA:
 290                         if videoinfo.has_key('url_encoded_fmt_stream_map'):
 291                                 (fmturl, fmtid) = fmtstring.split('&itag=')
 292                                 if fmturl.find("url=") !=-1:
 293                                         fmturl = fmturl.replace("url=","")
 294                         else:
 295                                 (fmtid,fmturl) = fmtstring.split('|')
 296                         if VIDEO_FMT_PRIORITY_MAP.has_key(fmtid):
 297                                 video_fmt_map[VIDEO_FMT_PRIORITY_MAP[fmtid]] = { 'fmtid': fmtid, 'fmturl': unquote_plus(fmturl) }
 298                         fmt_infomap[int(fmtid)] = unquote_plus(fmturl)
 299                 print "got",sorted(fmt_infomap.iterkeys())
 300                 if video_fmt_map and len(video_fmt_map):
 301                         video_url = video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmturl'].split(';')[0]
 302                         #print "found best available video format:",video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmtid']
 303                         #print "found best available video url:",video_url
 304                 return video_url
 305
 306         def run(self, tubeid, session, service):
 307                 try:
 308                         myurl = self.getVideoUrl(tubeid)
 309                         print "Playing URL", myurl
 310                         if myurl is None:
 311                                 session.open(MessageBox, _("Sorry, video is not available!"), MessageBox.TYPE_INFO)
 312                                 return
 313                         myreference = eServiceReference(4097, 0, myurl)
 314                         session.open(VuPlayer, myreference, service)
 315                 except Exception, msg:
 316                         wb_unlock()
 317                         print "Error >>", msg
 318
 319 class VuPlayerService:
 320         def __init__(self, session):
 321                 self.enable = False
 322                 self.socket_timeout = 0
 323                 self.max_buffer_size = 1024
 324                 self.uds_file = "/tmp/vuplus.tmp"
 325                 self.session = session
 326                 try:
 327                         os.remove(self.uds_file)
 328                 except OSError:
 329                         pass
 330
 331         def start(self, timeout = 1):
 332                 self.socket_timeout = timeout
 333                 thread.start_new_thread(self.run, (True,))
 334
 335         def stop(self):
 336                 self.enable = False
 337
 338         def isRunning(self):
 339                 return self.enable
 340
 341         def run(self, e = True):
 342                 if self.enable:
 343                         return
 344                 print "VuPlayerService start!!"
 345                 self.enable = e
 346                 self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 347                 self.sock.settimeout(self.socket_timeout)
 348                 self.sock.bind(self.uds_file)
 349                 self.sock.listen(1)
 350                 while(self.enable):
 351                         try:
 352                                 conn, addr = self.sock.accept()
 353                                 self.parseHandle(conn, addr)
 354                         except socket.timeout:
 355                                 #print "[socket timeout]"
 356                                 pass
 357                 print "VuPlayerService stop!!"
 358
 359         def parseHandle(self, conn, addr):
 360                 # [http://www.youtube.com/watch?v=BpThu778qB4&feature=related]
 361                 data = conn.recv(self.max_buffer_size)
 362                 print "[%s]" % (data)
 363                 enable_rc_mouse(False)
 364                 if data.startswith("http://www.youtube.com"):
 365                         print "youtube start!!"
 366                         tmp = data.split("?")
 367                         print tmp # ['http://www.youtube.com/watch', 'v=BpThu778qB4&feature=related']
 368                         service = self.session.nav.getCurrentlyPlayingServiceReference()
 369                         if len(tmp) == 2 and tmp[0] == "http://www.youtube.com/watch":
 370                                 tmp = tmp[1].split("&")
 371                                 print tmp # ['v=BpThu778qB4', 'feature=related']
 372                                 if len(tmp) > 2:
 373                                         tmp = tmp[0].split("=")
 374                                         print tmp # ['v', 'BpThu778qB4']
 375                                         if len(tmp) == 2 and tmp[0] == "v":
 376                                                 wb_lock()
 377                                                 player = VuPlayerLauncher()
 378                                                 player.run(tmp[1], self.session, service)
 379                                                 while wb_islock():
 380                                                         time.sleep(1)
 381                                                 self.session.nav.playService(service)
 382                                                 data = "ok$"
 383                                         else:
 384                                                 data = "nok$parsing fail"
 385                                 else:
 386                                         data = "nok$parsing fail"
 387                         else:
 388                                 data = "nok$parsing fail"
 389                         self.sendResponse(conn, data)
 390                 elif data.startswith("vk://open"):
 391                         print "virtual keyboard start!!"
 392                         from Screens.VirtualKeyBoard import VirtualKeyBoard
 393                         wb_lock()
 394                         self.vk_conn = conn
 395                         self.session.openWithCallback(self.cbOpenKeyboard, VirtualKeyBoard, title = (_("Enter your input data")), text = "")
 396
 397         def cbOpenKeyboard(self, data = None):
 398                 print "virtual keyboard callback!!"
 399                 wb_unlock()
 400                 self.sendResponse(self.vk_conn, data)
 401
 402         def sendResponse(self, conn, data):
 403                 if data is None or len(data) == 0:
 404                         data = ""
 405                 enable_rc_mouse(True)
 406                 conn.send(data)
 407                 conn.close()
 408
 409 class BrowserLauncher(ConfigListScreen, Screen):
 410         size = getDesktop(0).size()
 411         position_params = size.width() > 750 and (309,498, 0,150, 0,455) or (618,320, 312,5, 0,180)
 412         skin=   """
 413                 <screen name="BrowserLauncher" position="center,center" size="%d,%d" title="Web Browser">
 414                         <ePixmap pixmap="Vu_HD/buttons/red.png" position="4,0" size="40,40" alphatest="on" />
 415                         <ePixmap pixmap="Vu_HD/buttons/green.png" position="154,0" size="40,40" alphatest="on" />
 416
 417                         <widget source="key_red" render="Label" position="30,0" zPosition="1" size="125,30" font="Regular;20" halign="center" valign="center" transparent="1" />
 418                         <widget source="key_green" render="Label" position="180,0" zPosition="1" size="125,30" font="Regular;20" halign="center" valign="center" transparent="1" />
 419
 420                         <widget name="config" position="0,50" size="309,100" scrollbarMode="showOnDemand" />
 421                         <ePixmap pixmap="Vu_HD/rc_wb_desc.png" position="%d,%d" size="309,296" alphatest="on" />
 422                         <widget name="info" position="%d,%d" size="309,50" font="Regular;18" halign="center" foregroundColor="blue" transparent="1" />
 423                 </screen>
 424                 """ % position_params
 425
 426         def __init__(self, session):
 427                 Screen.__init__(self, session)
 428                 self.session = session
 429                 self.list = []
 430                 ConfigListScreen.__init__(self, self.list)
 431
 432                 self.browser_root = "/usr/bin"
 433                 self.browser_name = "arora"
 434
 435                 from Tools.Directories import resolveFilename, SCOPE_PLUGINS
 436                 self.conf_file = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/settings.conf")
 437                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
 438                 {       "red": self.keyCancel,
 439                         "green": self.keyGo,
 440                         "cancel": self.keyExit,
 441                 }, -2)
 442                 self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
 443                 self["info"] = self.info
 444                 self["key_red"] = StaticText(_("Exit"))
 445                 self["key_green"] = StaticText(_("Start"))
 446
 447                 self.conf_alpha = ""
 448                 self.conf_mouse = ""
 449                 self.conf_keyboard = ""
 450                 self.conf_keymap = ""
 451
 452                 self.usb_mouse = None
 453                 self.usb_keyboard = None
 454                 self.rc_mouse = None
 455                 self.rc_keyboard = None
 456
 457                 self.makeConfig()
 458                 #time.sleep(2)
 459
 460                 self.lock = False
 461                 self.vu_service = VuPlayerService(self.session)
 462                 self.vu_service.start(timeout=5)
 463
 464                 self.exit_wait_cond = False
 465                 self.timer_exit_cond = eTimer()
 466                 self.timer_exit_cond.callback.append(self.resetExitCond)
 467
 468                 self.test_cond = True
 469                 self.current_lang_idx = language.getActiveLanguageIndex()
 470
 471         def keyNone(self):
 472                 None
 473
 474         def doExit(self):
 475                 change_galpha(set_const=False, set_value=False)
 476                 self.saveConfig()
 477                 self.vu_service.stop()
 478                 excute_cmd("killall -15 %s"%(self.browser_name))
 479                 excute_cmd("echo 60 > /proc/sys/vm/swappiness")
 480                 enable_rc_mouse(False) #rc-mouse off
 481                 language.activateLanguageIndex(self.current_lang_idx)
 482                 fbClass.getInstance().unlock()
 483                 #eRCInput.getInstance().unlock()
 484                 self.close()
 485
 486         def keyExit(self):
 487                 if self.exit_wait_cond:
 488                         self.doExit()
 489                 if is_process_running(self.browser_name) == False:
 490                         self.doExit()
 491
 492         def keyLeft(self):
 493                 if is_process_running(self.browser_name) == False:
 494                         ConfigListScreen.keyLeft(self)
 495                         global alpha_value
 496                         alpha_value = self.alpha.value
 497                         #self.saveConfig()
 498
 499         def keyRight(self):
 500                 if is_process_running(self.browser_name) == False:
 501                         ConfigListScreen.keyRight(self)
 502                         alpha_value = self.alpha.value
 503                         #self.saveConfig()
 504
 505         def keyCancel(self):
 506                 if is_process_running(self.browser_name) == False:
 507                         self.doExit()
 508                 self.exit_wait_cond = True
 509                 self.timer_exit_cond.start(5000)
 510
 511         # mouse:keyboard:alpha_value
 512         def saveConfig(self):
 513                 if is_process_running(self.browser_name) == False:
 514                         command = "echo \"%s:%s:%d:%s\" > %s"%(self.mouse.value, self.keyboard.value, int(self.alpha.value), self.langs.value, self.conf_file)
 515                         excute_cmd(command)
 516
 517         # mouse:keyboard:alpha_value
 518         def loadConfig(self):
 519                 if os.path.exists(self.conf_file) == False:
 520                         return
 521                 config_list = open(self.conf_file).readline().strip().split(':')
 522                 if len(config_list) == 3:
 523                         self.conf_mouse         = config_list[0]
 524                         self.conf_keyboard      = config_list[1]
 525                         self.conf_alpha         = config_list[2]
 526                 elif len(config_list) == 4:
 527                         self.conf_mouse         = config_list[0]
 528                         self.conf_keyboard      = config_list[1]
 529                         self.conf_alpha         = config_list[2]
 530                         self.conf_keymap        = config_list[3]
 531                 print "load config : ", config_list
 532
 533         def resetExitCond(self):
 534                 self.timer_exit_cond.stop()
 535                 self.exit_wait_cond = False
 536
 537         def makeConfig(self):
 538                 self.loadConfig()
 539                 self.devices_string = ""
 540                 self.devices = eConsoleAppContainer()
 541                 self.devices.dataAvail.append(self.callbackDevicesDataAvail)
 542                 self.devices.appClosed.append(self.callbakcDevicesAppClose)
 543                 self.devices.execute(_("cat /proc/bus/input/devices"))
 544
 545         def callbackDevicesDataAvail(self, ret_data):
 546                 self.devices_string = self.devices_string + ret_data
 547
 548         def callbakcDevicesAppClose(self, retval):
 549                 self.name_list  = []
 550                 self.mouse_list = None
 551                 self.keyboard_list = None
 552
 553                 self.makeHandlerList(self.devices_string)
 554
 555                 if self.conf_mouse == "" or self.getHandlerName(self.conf_mouse) is None:
 556                         self.conf_mouse = self.mouse_list[0][0]
 557                 self.mouse = ConfigSelection(default = self.conf_mouse, choices = self.mouse_list)
 558                 self.list.append(getConfigListEntry(_('Mouse'), self.mouse))
 559
 560                 if self.conf_keyboard == "" or self.getHandlerName(self.conf_keyboard) is None:
 561                         self.conf_keyboard = self.keyboard_list[0][0]
 562                 self.keyboard = ConfigSelection(default = self.conf_keyboard, choices = self.keyboard_list)
 563                 self.list.append(getConfigListEntry(_('Keyboard'), self.keyboard))
 564
 565                 if self.conf_keymap == "":
 566                         self.conf_keymap = self.getLanguage()
 567                 self.lang_list = [("rc_en", "English(RC)"), ("rc_ch", "German(RC)"), ("en", "English"), ("ch", "German")]
 568                 self.langs = ConfigSelection(default = self.conf_keymap, choices = self.lang_list)
 569                 self.list.append(getConfigListEntry(_("    - Type"), self.langs))
 570
 571                 if self.conf_alpha == "":
 572                         self.conf_alpha = "255"
 573                 self.alpha = ConfigSlider(default = int(self.conf_alpha), increment = 10, limits = (0, 255))
 574                 self.list.append(getConfigListEntry(_("Alpha Value"), self.alpha))
 575                 self["config"].list = self.list
 576                 self["config"].l.setList(self.list)
 577
 578         def getLanguage(self, lang=language.getLanguage()):
 579                 if self.current_lang_idx == 1:
 580                         return "rc_ch"
 581                 return "rc_en"
 582
 583         def makeHandlerList(self, data):
 584                 n = ""
 585                 p = ""
 586                 h_list = []
 587
 588                 event_list = []
 589                 lines = data.split('\n')
 590                 for line in lines:
 591                         print ">>", line
 592                         if line is not None and len(line) > 0:
 593                                 if line[0] == 'I':
 594                                         n = ""
 595                                         p = ""
 596                                         h_list = []
 597                                 elif line[0] == 'N':
 598                                         n = line[8:].strip()
 599                                 elif line[0] == 'P':
 600                                         p = line[8:].strip()
 601                                 elif line[0] == 'H':
 602                                         h_list = line[12:].strip().split()
 603                                         tn = line[12:].strip().find("mouse")
 604                                         for h in h_list:
 605                                                 event_list.append((h, _(h)))
 606                                                 self.name_list.append((h, n))
 607                                                 if n[1:].startswith("dream") and self.rc_mouse is None:
 608                                                         for thl in h.split(" "):
 609                                                                 if thl.startswith("event"):
 610                                                                         self.rc_mouse = copy.deepcopy(h)
 611                                                                         self.rc_keyboard = copy.deepcopy(h)
 612                                                                         print "detected!! rc:", h
 613                                                         continue
 614                                                 if h.startswith("mouse") and self.usb_mouse is None:
 615                                                         self.usb_mouse = copy.deepcopy(h)
 616                                                         print "detected!! usb mouse:",h
 617                                                         continue
 618                                                 if tn == -1 and self.usb_keyboard is None:
 619                                                         self.usb_keyboard = copy.deepcopy(h)
 620                                                         print "detected!! usb keyboard:",h
 621                                 elif line[0] == 'B' and line[3:].startswith("ABS") and p.startswith("usb-"):
 622                                         for h in h_list:
 623                                                 if self.usb_mouse is not None:
 624                                                         break
 625                                                 if self.usb_keyboard is not None and h == self.usb_keyboard[0]:
 626                                                         self.usb_keyboard = None
 627                                                         print "clean!! usb keyboard:",h
 628                                                 self.usb_mouse = copy.deepcopy(h)
 629                                                 print "detected!! usb mouse:",h
 630
 631                 tmp = copy.deepcopy(event_list)
 632                 if self.usb_mouse is not None:
 633                         tmp.insert(0, ("musb", "USB Mouse"))
 634                 if self.rc_mouse is not None:
 635                         tmp.insert(0, ("mrc", "Remote Control"))
 636                 self.mouse_list = tmp
 637
 638                 tmp = copy.deepcopy(event_list)
 639                 if self.usb_keyboard is not None:
 640                         tmp.insert(0, ("kusb", "USB Keyboard"))
 641                 if self.rc_keyboard is not None:
 642                         tmp.insert(0, ("krc", "Remote Control"))
 643                 self.keyboard_list = tmp
 644                 print "E:", event_list
 645                 print "M:", self.mouse_list
 646                 print "K:", self.keyboard_list
 647
 648         def startBrowser(self):
 649                 self.timer_start.stop()
 650
 651                 self.lock = True
 652                 excute_cmd("killall -15 %s"%(self.browser_name))
 653                 excute_cmd("echo 0 > /proc/sys/vm/swappiness")
 654
 655                 kbd_cmd = " "
 656                 mouse_cmd = " "
 657                 extra_cmd = "export VU_DOWNLOAD_DIR=/tmp; "
 658                 browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)
 659
 660                 mouse_param = self.mouse.value
 661                 if self.mouse.value == "mrc":
 662                         mouse_param = self.rc_mouse
 663                 elif self.mouse.value == "musb":
 664                         mouse_param = self.usb_mouse
 665                 keyboard_param = self.keyboard.value
 666                 if self.keyboard.value == "krc":
 667                         keyboard_param = self.rc_keyboard
 668                 elif self.keyboard.value == "kusb":
 669                         keyboard_param = self.usb_keyboard
 670
 671                 if self.getHandlerName(mouse_param)[1:].startswith("dreambox"):
 672                         enable_rc_mouse(True) #rc-mouse on
 673                 if str(mouse_param).startswith("event"):
 674                         mouse_cmd = "export QWS_MOUSE_PROTO=LinuxInput:/dev/input/%s; " % (str(mouse_param))
 675
 676                 keymap_param = ""
 677                 if self.langs.value == "ch":
 678                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/ch.qmap"
 679                 elif self.langs.value == "rc_ch":
 680                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/de.qmap"
 681                 elif self.langs.value == "rc_en":
 682                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/us.qmap"
 683
 684                 kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s%s; " % (str(keyboard_param), keymap_param)
 685
 686                 cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
 687                 print "prepared command : [%s]" % cmd
 688
 689                 self.launcher = eConsoleAppContainer()
 690                 self.launcher.appClosed.append(self.callbackLauncherAppClosed)
 691                 self.launcher.dataAvail.append(self.callbackLauncherDataAvail)
 692
 693                 fbClass.getInstance().lock()
 694                 #eRCInput.getInstance().lock()
 695
 696                 global alpha_value
 697                 alpha_value = self.alpha.value
 698                 change_galpha(set_const=True, set_value=True)
 699
 700                 self.launcher.execute(cmd)
 701                 print "started browser..."
 702
 703         def keyGo(self):
 704                 self.saveConfig()
 705                 self.info.setText("Starting Webbrowser. Please wait...")
 706                 if self.lock == False:
 707                         if self.langs.value == "ch" or self.langs.value == "rc_ch":
 708                                 language.activateLanguageIndex(1)
 709                         else:
 710                                 language.activateLanguageIndex(0)
 711                         self.timer_start = eTimer()
 712                         self.timer_start.callback.append(self.startBrowser)
 713                         self.timer_start.start(10)
 714
 715         def getHandlerName(self, v):
 716                 if v == "mrc":
 717                         v = self.rc_mouse
 718                 elif v == "musb":
 719                         v = self.usb_mouse
 720                 elif v == "krc":
 721                         v = self.rc_keyboard
 722                 elif v == "kusb":
 723                         v = self.usb_keyboard
 724                 for l in self.name_list:
 725                         if l[0] == v:
 726                                 return l[1]
 727                 return None
 728
 729         def callbackLauncherDataAvail(self, ret_data):
 730                 print ret_data
 731                 if ret_data.startswith("--done--"):
 732                         self.lock = False
 733                         self.doExit()
 734
 735         def callbackLauncherAppClosed(self, retval = 1):
 736                 self.lock = False
 737
 738 def sessionstart(session, **kwargs):
 739         enable_rc_mouse(False)
 740         change_galpha(set_const=False, set_value=True)
 741         excute_cmd("killall -15 arora")
 742
 743 def main(session, **kwargs):
 744         session.open(BrowserLauncher)
 745
 746 def Plugins(**kwargs):
 747         return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, needsRestart = False, fnc=sessionstart),
 748                 PluginDescriptor(name=_("Web Browser"), description="start web browser", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)]
 749
 750