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