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