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="154,0" size="40,40" alphatest="on" />
 411
 412                         <widget source="key_red" render="Label" position="30,0" zPosition="1" size="125,30" font="Regular;20" halign="center" valign="center" transparent="1" />
 413                         <widget source="key_green" render="Label" position="180,0" zPosition="1" size="125,30" font="Regular;20" halign="center" valign="center" transparent="1" />
 414
 415                         <widget name="config" position="0,50" size="309,100" scrollbarMode="showOnDemand" />
 416                         <ePixmap pixmap="Vu_HD/rc_wb_desc.png" position="0,150" size="309,296" alphatest="on" />
 417                         <widget name="info" position="0,455" size="309,50" font="Regular;18" halign="center" foregroundColor="blue" transparent="1" />
 418                 </screen>
 419                 """
 420
 421         def __init__(self, session):
 422                 Screen.__init__(self, session)
 423                 self.session = session
 424                 self.list = []
 425                 ConfigListScreen.__init__(self, self.list)
 426
 427                 self.browser_root = "/usr/bin"
 428                 self.browser_name = "arora"
 429
 430                 from Tools.Directories import resolveFilename, SCOPE_PLUGINS
 431                 self.conf_file = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/settings.conf")
 432                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
 433                 {       "red": self.keyCancel,
 434                         "green": self.keyGo,
 435                         "cancel": self.keyExit,
 436                 }, -2)
 437                 self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
 438                 self["info"] = self.info
 439                 self["key_red"] = StaticText(_("Exit"))
 440                 self["key_green"] = StaticText(_("Start"))
 441
 442                 self.conf_alpha = ""
 443                 self.conf_mouse = ""
 444                 self.conf_keyboard = ""
 445                 self.conf_keymap = ""
 446
 447                 self.usb_mouse = None
 448                 self.usb_keyboard = None
 449                 self.rc_mouse = None
 450                 self.rc_keyboard = None
 451
 452                 self.makeConfig()
 453                 #time.sleep(2)
 454
 455                 self.lock = False
 456                 self.vu_service = VuPlayerService(self.session)
 457                 self.vu_service.start(timeout=5)
 458
 459                 self.exit_wait_cond = False
 460                 self.timer_exit_cond = eTimer()
 461                 self.timer_exit_cond.callback.append(self.resetExitCond)
 462
 463                 self.test_cond = True
 464                 self.current_lang_idx = language.getActiveLanguageIndex()
 465
 466         def keyNone(self):
 467                 None
 468
 469         def doExit(self):
 470                 change_galpha(set_const=False, set_value=False)
 471                 self.saveConfig()
 472                 self.vu_service.stop()
 473                 excute_cmd("killall -15 %s"%(self.browser_name))
 474                 excute_cmd("echo 60 > /proc/sys/vm/swappiness")
 475                 enable_rc_mouse(False) #rc-mouse off
 476                 language.activateLanguageIndex(self.current_lang_idx)
 477                 fbClass.getInstance().unlock()
 478                 #eRCInput.getInstance().unlock()
 479                 self.close()
 480
 481         def keyExit(self):
 482                 if self.exit_wait_cond:
 483                         self.doExit()
 484                 if is_process_running(self.browser_name) == False:
 485                         self.doExit()
 486
 487         def keyLeft(self):
 488                 if is_process_running(self.browser_name) == False:
 489                         ConfigListScreen.keyLeft(self)
 490                         global alpha_value
 491                         alpha_value = self.alpha.value
 492                         #self.saveConfig()
 493
 494         def keyRight(self):
 495                 if is_process_running(self.browser_name) == False:
 496                         ConfigListScreen.keyRight(self)
 497                         alpha_value = self.alpha.value
 498                         #self.saveConfig()
 499
 500         def keyCancel(self):
 501                 if is_process_running(self.browser_name) == False:
 502                         self.doExit()
 503                 self.exit_wait_cond = True
 504                 self.timer_exit_cond.start(5000)
 505
 506         # mouse:keyboard:alpha_value
 507         def saveConfig(self):
 508                 if is_process_running(self.browser_name) == False:
 509                         command = "echo \"%s:%s:%d:%s\" > %s"%(self.mouse.value, self.keyboard.value, int(self.alpha.value), self.langs.value, self.conf_file)
 510                         excute_cmd(command)
 511
 512         # mouse:keyboard:alpha_value
 513         def loadConfig(self):
 514                 if os.path.exists(self.conf_file) == False:
 515                         return
 516                 config_list = open(self.conf_file).readline().strip().split(':')
 517                 if len(config_list) == 3:
 518                         self.conf_mouse         = config_list[0]
 519                         self.conf_keyboard      = config_list[1]
 520                         self.conf_alpha         = config_list[2]
 521                 elif len(config_list) == 4:
 522                         self.conf_mouse         = config_list[0]
 523                         self.conf_keyboard      = config_list[1]
 524                         self.conf_alpha         = config_list[2]
 525                         self.conf_keymap        = config_list[3]
 526                 print "load config : ", config_list
 527
 528         def resetExitCond(self):
 529                 self.timer_exit_cond.stop()
 530                 self.exit_wait_cond = False
 531
 532         def makeConfig(self):
 533                 self.loadConfig()
 534                 self.devices_string = ""
 535                 self.devices = eConsoleAppContainer()
 536                 self.devices.dataAvail.append(self.callbackDevicesDataAvail)
 537                 self.devices.appClosed.append(self.callbakcDevicesAppClose)
 538                 self.devices.execute(_("cat /proc/bus/input/devices"))
 539
 540         def callbackDevicesDataAvail(self, ret_data):
 541                 self.devices_string = self.devices_string + ret_data
 542
 543         def callbakcDevicesAppClose(self, retval):
 544                 self.name_list  = []
 545                 self.mouse_list = None
 546                 self.keyboard_list = None
 547
 548                 self.makeHandlerList(self.devices_string)
 549
 550                 if self.conf_mouse == "" or self.getHandlerName(self.conf_mouse) is None:
 551                         self.conf_mouse = self.mouse_list[0][0]
 552                 self.mouse = ConfigSelection(default = self.conf_mouse, choices = self.mouse_list)
 553                 self.list.append(getConfigListEntry(_('Mouse'), self.mouse))
 554
 555                 if self.conf_keyboard == "" or self.getHandlerName(self.conf_keyboard) is None:
 556                         self.conf_keyboard = self.keyboard_list[0][0]
 557                 self.keyboard = ConfigSelection(default = self.conf_keyboard, choices = self.keyboard_list)
 558                 self.list.append(getConfigListEntry(_('Keyboard'), self.keyboard))
 559
 560                 if self.conf_keymap == "":
 561                         self.conf_keymap = self.getLanguage()
 562                 self.lang_list = [("rc_en", "English(RC)"), ("rc_ch", "German(RC)"), ("en", "English"), ("ch", "German")]
 563                 self.langs = ConfigSelection(default = self.conf_keymap, choices = self.lang_list)
 564                 self.list.append(getConfigListEntry(_("    - Type"), self.langs))
 565
 566                 if self.conf_alpha == "":
 567                         self.conf_alpha = "255"
 568                 self.alpha = ConfigSlider(default = int(self.conf_alpha), increment = 10, limits = (0, 255))
 569                 self.list.append(getConfigListEntry(_("Alpha Value"), self.alpha))
 570                 self["config"].list = self.list
 571                 self["config"].l.setList(self.list)
 572
 573         def getLanguage(self, lang=language.getLanguage()):
 574                 if self.current_lang_idx == 1:
 575                         return "rc_ch"
 576                 return "rc_en"
 577
 578         def makeHandlerList(self, data):
 579                 n = ""
 580                 p = ""
 581                 h_list = []
 582
 583                 event_list = []
 584                 lines = data.split('\n')
 585                 for line in lines:
 586                         print ">>", line
 587                         if line is not None and len(line) > 0:
 588                                 if line[0] == 'I':
 589                                         n = ""
 590                                         p = ""
 591                                         h_list = []
 592                                 elif line[0] == 'N':
 593                                         n = line[8:].strip()
 594                                 elif line[0] == 'P':
 595                                         p = line[8:].strip()
 596                                 elif line[0] == 'H':
 597                                         h_list = line[12:].strip().split()
 598                                         tn = line[12:].strip().find("mouse")
 599                                         for h in h_list:
 600                                                 event_list.append((h, _(h)))
 601                                                 self.name_list.append((h, n))
 602                                                 if n[1:].startswith("dream") and self.rc_mouse is None:
 603                                                         for thl in h.split(" "):
 604                                                                 if thl.startswith("event"):
 605                                                                         self.rc_mouse = copy.deepcopy(h)
 606                                                                         self.rc_keyboard = copy.deepcopy(h)
 607                                                                         print "detected!! rc:", h
 608                                                         continue
 609                                                 if h.startswith("mouse") and self.usb_mouse is None:
 610                                                         self.usb_mouse = copy.deepcopy(h)
 611                                                         print "detected!! usb mouse:",h
 612                                                         continue
 613                                                 if tn == -1 and self.usb_keyboard is None:
 614                                                         self.usb_keyboard = copy.deepcopy(h)
 615                                                         print "detected!! usb keyboard:",h
 616                                 elif line[0] == 'B' and line[3:].startswith("ABS") and p.startswith("usb-"):
 617                                         for h in h_list:
 618                                                 if self.usb_mouse is not None:
 619                                                         break
 620                                                 if self.usb_keyboard is not None and h == self.usb_keyboard[0]:
 621                                                         self.usb_keyboard = None
 622                                                         print "clean!! usb keyboard:",h
 623                                                 self.usb_mouse = copy.deepcopy(h)
 624                                                 print "detected!! usb mouse:",h
 625
 626                 tmp = copy.deepcopy(event_list)
 627                 if self.usb_mouse is not None:
 628                         tmp.insert(0, ("musb", "USB Mouse"))
 629                 if self.rc_mouse is not None:
 630                         tmp.insert(0, ("mrc", "Remote Control"))
 631                 self.mouse_list = tmp
 632
 633                 tmp = copy.deepcopy(event_list)
 634                 if self.usb_keyboard is not None:
 635                         tmp.insert(0, ("kusb", "USB Keyboard"))
 636                 if self.rc_keyboard is not None:
 637                         tmp.insert(0, ("krc", "Remote Control"))
 638                 self.keyboard_list = tmp
 639                 print "E:", event_list
 640                 print "M:", self.mouse_list
 641                 print "K:", self.keyboard_list
 642
 643         def startBrowser(self):
 644                 self.timer_start.stop()
 645
 646                 self.lock = True
 647                 excute_cmd("killall -15 %s"%(self.browser_name))
 648                 excute_cmd("echo 0 > /proc/sys/vm/swappiness")
 649
 650                 kbd_cmd = " "
 651                 mouse_cmd = " "
 652                 extra_cmd = "export VU_DOWNLOAD_DIR=/tmp; "
 653                 browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)
 654
 655                 mouse_param = self.mouse.value
 656                 if self.mouse.value == "mrc":
 657                         mouse_param = self.rc_mouse
 658                 elif self.mouse.value == "musb":
 659                         mouse_param = self.usb_mouse
 660                 keyboard_param = self.keyboard.value
 661                 if self.keyboard.value == "krc":
 662                         keyboard_param = self.rc_keyboard
 663                 elif self.keyboard.value == "kusb":
 664                         keyboard_param = self.usb_keyboard
 665
 666                 if self.getHandlerName(mouse_param)[1:].startswith("dreambox"):
 667                         enable_rc_mouse(True) #rc-mouse on
 668                 if str(mouse_param).startswith("event"):
 669                         mouse_cmd = "export QWS_MOUSE_PROTO=LinuxInput:/dev/input/%s; " % (str(mouse_param))
 670
 671                 keymap_param = ""
 672                 if self.langs.value == "ch":
 673                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/ch.qmap"
 674                 elif self.langs.value == "rc_ch":
 675                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/de.qmap"
 676                 elif self.langs.value == "rc_en":
 677                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/us.qmap"
 678
 679                 kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s%s; " % (str(keyboard_param), keymap_param)
 680
 681                 cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
 682                 print "prepared command : [%s]" % cmd
 683
 684                 self.launcher = eConsoleAppContainer()
 685                 self.launcher.appClosed.append(self.callbackLauncherAppClosed)
 686                 self.launcher.dataAvail.append(self.callbackLauncherDataAvail)
 687
 688                 fbClass.getInstance().lock()
 689                 #eRCInput.getInstance().lock()
 690
 691                 global alpha_value
 692                 alpha_value = self.alpha.value
 693                 change_galpha(set_const=True, set_value=True)
 694
 695                 self.launcher.execute(cmd)
 696                 print "started browser..."
 697
 698         def keyGo(self):
 699                 self.saveConfig()
 700                 self.info.setText("Starting Webbrowser. Please wait...")
 701                 if self.lock == False:
 702                         if self.langs.value == "ch" or self.langs.value == "rc_ch":
 703                                 language.activateLanguageIndex(1)
 704                         else:
 705                                 language.activateLanguageIndex(0)
 706                         self.timer_start = eTimer()
 707                         self.timer_start.callback.append(self.startBrowser)
 708                         self.timer_start.start(10)
 709
 710         def getHandlerName(self, v):
 711                 if v == "mrc":
 712                         v = self.rc_mouse
 713                 elif v == "musb":
 714                         v = self.usb_mouse
 715                 elif v == "krc":
 716                         v = self.rc_keyboard
 717                 elif v == "kusb":
 718                         v = self.usb_keyboard
 719                 for l in self.name_list:
 720                         if l[0] == v:
 721                                 return l[1]
 722                 return None
 723
 724         def callbackLauncherDataAvail(self, ret_data):
 725                 print ret_data
 726                 if ret_data.startswith("--done--"):
 727                         self.lock = False
 728                         self.doExit()
 729
 730         def callbackLauncherAppClosed(self, retval = 1):
 731                 self.lock = False
 732
 733 def sessionstart(session, **kwargs):
 734         enable_rc_mouse(False)
 735         change_galpha(set_const=False, set_value=True)
 736         excute_cmd("killall -15 arora")
 737
 738 def main(session, **kwargs):
 739         session.open(BrowserLauncher)
 740
 741 def Plugins(**kwargs):
 742         return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, needsRestart = False, fnc=sessionstart),
 743                 PluginDescriptor(name=_("Web Browser"), description="start web browser", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)]
 744
 745