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         QUALITY_CODE =  {
 252                          '5': 'FLV 224p'
 253                         ,'6': 'FLV 270p'
 254                         ,'34':'FLV 360p'
 255                         ,'35':'FLV 480p'
 256                         ,'18':'MP4 360p'
 257                         ,'22':'MP4 720p'
 258                         ,'37':'MP4 1080p'
 259                         ,'38':'MP4 2304p'
 260                         ,'83':'MP4-3D 240p'
 261                         ,'82':'MP4-3D 360p'
 262                         ,'85':'MP4-3D 520p'
 263                         ,'84':'MP4-3D 720p'
 264                         ,'43':'WebM 360p'
 265                         ,'44':'WebM 480p'
 266                         ,'45':'WebM 720p'
 267                         ,'46':'WebM 1080p'
 268                         ,'100':'WebM-3D 360p'
 269                         ,'101':'WebM-3D 480p'
 270                         ,'102':'WebM-3D 720p'
 271                         ,'13':'3GP 0.5'
 272                         ,'17':'3GP 2.0'
 273                         }
 274         def getVideoUrl(self, video_id):
 275                 video_url = None
 276
 277                 if video_id is None or video_id == "":
 278                         return video_url
 279
 280                 # Getting video webpage
 281                 watch_url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id
 282                 watchrequest = Request(watch_url, None, std_headers)
 283                 try:
 284                         #print "trying to find out if a HD Stream is available",watch_url
 285                         watchvideopage = urlopen2(watchrequest).read()
 286                 except (URLError, HTTPException, socket.error), err:
 287                         print "Error: Unable to retrieve watchpage - Error code: ", str(err)
 288                         return video_url
 289
 290                 # Get video info
 291                 for el in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
 292                         info_url = ('http://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en' % (video_id, el))
 293                         request = Request(info_url, None, std_headers)
 294                         try:
 295                                 infopage = urlopen2(request).read()
 296                                 videoinfo = parse_qs(infopage)
 297                                 if ('url_encoded_fmt_stream_map' or 'fmt_url_map') in videoinfo:
 298                                         break
 299                         except (URLError, HTTPException, socket.error), err:
 300                                 print "Error: unable to download video infopage",str(err)
 301                                 return video_url
 302
 303                 if ('url_encoded_fmt_stream_map' or 'fmt_url_map') not in videoinfo:
 304                         if 'reason' not in videoinfo:
 305                                 print 'Error: unable to extract "fmt_url_map" or "url_encoded_fmt_stream_map" parameter for unknown reason'
 306                         else:
 307                                 reason = unquote_plus(videoinfo['reason'][0])
 308                                 print 'Error: YouTube said: %s' % reason.decode('utf-8')
 309                         return video_url
 310
 311                 video_fmt_map = {}
 312                 fmt_infomap = {}
 313                 if videoinfo.has_key('url_encoded_fmt_stream_map'):
 314                         tmp_fmtUrlDATA = videoinfo['url_encoded_fmt_stream_map'][0].split(',url=')
 315                 else:
 316                         tmp_fmtUrlDATA = videoinfo['fmt_url_map'][0].split(',')
 317                 for fmtstring in tmp_fmtUrlDATA:
 318                         if videoinfo.has_key('url_encoded_fmt_stream_map'):
 319                                 (fmturl, fmtid) = fmtstring.split('&itag=')
 320                                 if fmturl.find("url=") !=-1:
 321                                         fmturl = fmturl.replace("url=","")
 322                         else:
 323                                 (fmtid,fmturl) = fmtstring.split('|')
 324                         if VIDEO_FMT_PRIORITY_MAP.has_key(fmtid):
 325                                 video_fmt_map[VIDEO_FMT_PRIORITY_MAP[fmtid]] = { 'fmtid': fmtid, 'fmturl': unquote_plus(fmturl) }
 326                         fmt_infomap[int(fmtid)] = unquote_plus(fmturl)
 327                 print "fmtinfomap :",sorted(fmt_infomap.iterkeys())
 328
 329                 video_url_list = []
 330                 if video_fmt_map:
 331                         idx = 0
 332                         sorted_fmt_keys = sorted(video_fmt_map.iterkeys())
 333                         for x in video_fmt_map:
 334                                 try:
 335                                         videofmt    = video_fmt_map[sorted_fmt_keys[idx]]
 336                                         video_url   = videofmt['fmturl'].split(';')[0]
 337                                         quality_str = self.qCode2String(videofmt['fmtid'])
 338                                         #print "detected video : quality [%s], url [%s]" % (quality_str, video_url)
 339                                         if video_url and quality_str:
 340                                                 video_url_list.append((quality_str, video_url))
 341                                                 print "added quality [%s], url [%s]" % (quality_str, video_url)
 342                                 except Exception, msg: print "Error >>", msg
 343                                 idx = idx + 1
 344                 return video_url_list
 345
 346         def qCode2String(self, qcode):
 347                 qstr = None
 348                 try:
 349                         qstr = self.QUALITY_CODE[qcode]
 350                 except: pass
 351                 #print "quality : code[%s], str[%s]" % (qcode, qstr)
 352                 return qstr
 353
 354         def run(self, tubeid, session, service):
 355                 self.session = session
 356                 self.service = service
 357                 try:
 358                         self.url_list = self.getVideoUrl(tubeid)
 359                         if self.url_list is None or len(self.url_list) == 0:
 360                                 session.open(MessageBox, _("Sorry, video is not available!"), MessageBox.TYPE_INFO)
 361                                 wb_unlock()
 362                                 return
 363                         titlemsg = "Please, choice video quality.\nFor smooth playback depends on network conditions."
 364                         self.session.openWithCallback(self.cbSelectedQuality, ChoiceBox, title=_(titlemsg), list = self.url_list)
 365                 except Exception, msg:
 366                         wb_unlock()
 367                         print "Error >>", msg
 368
 369         def cbSelectedQuality(self, choice):
 370                 try:
 371                         print "selected [%s] : [%s]" % (choice[0], choice[1])
 372                         myreference = eServiceReference(4097, 0, choice[1])
 373                         self.session.open(VuPlayer, myreference, self.service)
 374                 except Exception, msg:
 375                         wb_unlock()
 376                         print "Error >>", msg
 377
 378 class VuPlayerService:
 379         def __init__(self, session):
 380                 self.enable = False
 381                 self.socket_timeout = 0
 382                 self.max_buffer_size = 1024
 383                 self.uds_file = "/tmp/vuplus.tmp"
 384                 self.session = session
 385                 try:
 386                         os.remove(self.uds_file)
 387                 except OSError:
 388                         pass
 389
 390         def start(self, timeout = 1):
 391                 self.socket_timeout = timeout
 392                 thread.start_new_thread(self.run, (True,))
 393
 394         def stop(self):
 395                 self.enable = False
 396
 397         def isRunning(self):
 398                 return self.enable
 399
 400         def run(self, e = True):
 401                 if self.enable:
 402                         return
 403                 print "VuPlayerService start!!"
 404                 self.enable = e
 405                 self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 406                 self.sock.settimeout(self.socket_timeout)
 407                 self.sock.bind(self.uds_file)
 408                 self.sock.listen(1)
 409                 while(self.enable):
 410                         try:
 411                                 conn, addr = self.sock.accept()
 412                                 self.parseHandle(conn, addr)
 413                         except socket.timeout:
 414                                 #print "[socket timeout]"
 415                                 pass
 416                 print "VuPlayerService stop!!"
 417
 418         def parseHandle(self, conn, addr):
 419                 # [http://www.youtube.com/watch?v=BpThu778qB4&feature=related]
 420                 data = conn.recv(self.max_buffer_size)
 421                 print "[%s]" % (data)
 422                 enable_rc_mouse(False)
 423                 if data.startswith("http://www.youtube.com"):
 424                         print "youtube start!!"
 425                         tmp = data.split("?")
 426                         print tmp # ['http://www.youtube.com/watch', 'v=BpThu778qB4&feature=related']
 427                         service = self.session.nav.getCurrentlyPlayingServiceReference()
 428                         if len(tmp) and tmp[0] == "http://www.youtube.com/watch":
 429                                 tmp = tmp[1].split("&")
 430                                 print tmp # ['v=BpThu778qB4', 'feature=related']
 431                                 if len(tmp):
 432                                         tmp = tmp[0].split("=")
 433                                         print tmp # ['v', 'BpThu778qB4']
 434                                         if len(tmp) == 2 and tmp[0] == "v":
 435                                                 wb_lock()
 436                                                 player = VuPlayerLauncher()
 437                                                 player.run(tmp[1], self.session, service)
 438                                                 while wb_islock():
 439                                                         time.sleep(1)
 440                                                 self.session.nav.playService(service)
 441                                                 data = "ok$"
 442                                         else:
 443                                                 data = "nok$parsing fail"
 444                                 else:
 445                                         data = "nok$parsing fail"
 446                         else:
 447                                 data = "nok$parsing fail"
 448                         self.sendResponse(conn, data)
 449                 elif data.startswith("vk://open"):
 450                         print "virtual keyboard start!!"
 451                         from Screens.VirtualKeyBoard import VirtualKeyBoard
 452                         wb_lock()
 453                         self.vk_conn = conn
 454                         self.session.openWithCallback(self.cbOpenKeyboard, VirtualKeyBoard, title = (_("Enter your input data")), text = "")
 455
 456         def cbOpenKeyboard(self, data = None):
 457                 print "virtual keyboard callback!!"
 458                 wb_unlock()
 459                 self.sendResponse(self.vk_conn, data)
 460
 461         def sendResponse(self, conn, data):
 462                 if data is None or len(data) == 0:
 463                         data = ""
 464                 enable_rc_mouse(True)
 465                 conn.send(data)
 466                 conn.close()
 467
 468 class BrowserLauncher(ConfigListScreen, Screen):
 469         skin=   """
 470                 <screen position="center,center" size="623,300" title="Web Browser">
 471                         <ePixmap pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" />
 472                         <ePixmap pixmap="skin_default/buttons/green.png" position="158,0" size="140,40" alphatest="on" />
 473
 474                         <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" />
 475                         <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" />
 476
 477                         <widget name="config" position="0,50" size="309,100" scrollbarMode="showOnDemand" />
 478                         <ePixmap pixmap="rc_wb_desc.png" position="312,5" size="309,296" alphatest="on" />
 479                         <widget name="info" position="0,180" size="309,50" font="Regular;18" halign="center" foregroundColor="#a08500" transparent="1" />
 480                 </screen>
 481                 """
 482
 483         def __init__(self, session):
 484                 Screen.__init__(self, session)
 485
 486
 487                 self.session = session
 488                 self.list = []
 489                 ConfigListScreen.__init__(self, self.list)
 490
 491                 self.browser_root = "/usr/bin"
 492                 self.browser_name = "arora"
 493
 494                 from Tools.Directories import resolveFilename, SCOPE_PLUGINS
 495                 self.conf_file = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/settings.conf")
 496                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
 497                 {       "red": self.keyCancel,
 498                         "green": self.keyGo,
 499                         "cancel": self.keyExit,
 500                 }, -2)
 501                 self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
 502                 self["info"] = self.info
 503                 self["key_red"] = StaticText(_("Exit"))
 504                 self["key_green"] = StaticText(_("Start"))
 505
 506                 self.conf_alpha = ""
 507                 self.conf_mouse = ""
 508                 self.conf_keyboard = ""
 509                 self.conf_keymap = ""
 510
 511                 self.usb_mouse = None
 512                 self.usb_keyboard = None
 513                 self.rc_mouse = None
 514                 self.rc_keyboard = None
 515
 516                 self.makeConfig()
 517                 #time.sleep(2)
 518
 519                 self.lock = False
 520                 self.vu_service = VuPlayerService(self.session)
 521                 self.vu_service.start(timeout=5)
 522
 523                 self.exit_wait_cond = False
 524                 self.timer_exit_cond = eTimer()
 525                 self.timer_exit_cond.callback.append(self.resetExitCond)
 526
 527                 self.test_cond = True
 528                 self.current_lang_idx = language.getActiveLanguageIndex()
 529
 530         def keyNone(self):
 531                 None
 532
 533         def doExit(self):
 534                 change_galpha(set_const=False, set_value=False)
 535                 self.saveConfig()
 536                 self.vu_service.stop()
 537                 excute_cmd("killall -15 %s"%(self.browser_name))
 538                 excute_cmd("echo 60 > /proc/sys/vm/swappiness")
 539                 enable_rc_mouse(False) #rc-mouse off
 540                 language.activateLanguageIndex(self.current_lang_idx)
 541                 fbClass.getInstance().unlock()
 542                 #eRCInput.getInstance().unlock()
 543                 self.close()
 544
 545         def keyExit(self):
 546                 if self.exit_wait_cond:
 547                         self.doExit()
 548                 if is_process_running(self.browser_name) == False:
 549                         self.doExit()
 550
 551         def keyLeft(self):
 552                 if is_process_running(self.browser_name) == False:
 553                         ConfigListScreen.keyLeft(self)
 554                         global alpha_value
 555                         alpha_value = self.alpha.value
 556                         #self.saveConfig()
 557
 558         def keyRight(self):
 559                 if is_process_running(self.browser_name) == False:
 560                         ConfigListScreen.keyRight(self)
 561                         alpha_value = self.alpha.value
 562                         #self.saveConfig()
 563
 564         def keyCancel(self):
 565                 if is_process_running(self.browser_name) == False:
 566                         self.doExit()
 567                 self.exit_wait_cond = True
 568                 self.timer_exit_cond.start(5000)
 569
 570         # mouse:keyboard:alpha_value
 571         def saveConfig(self):
 572                 if is_process_running(self.browser_name) == False:
 573                         command = "echo \"%s:%s:%d:%s\" > %s"%(self.mouse.value, self.keyboard.value, int(self.alpha.value), self.langs.value, self.conf_file)
 574                         excute_cmd(command)
 575
 576         # mouse:keyboard:alpha_value
 577         def loadConfig(self):
 578                 if os.path.exists(self.conf_file) == False:
 579                         return
 580                 config_list = open(self.conf_file).readline().strip().split(':')
 581                 if len(config_list) == 3:
 582                         self.conf_mouse         = config_list[0]
 583                         self.conf_keyboard      = config_list[1]
 584                         self.conf_alpha         = config_list[2]
 585                 elif len(config_list) == 4:
 586                         self.conf_mouse         = config_list[0]
 587                         self.conf_keyboard      = config_list[1]
 588                         self.conf_alpha         = config_list[2]
 589                         self.conf_keymap        = config_list[3]
 590                 print "load config : ", config_list
 591
 592         def resetExitCond(self):
 593                 self.timer_exit_cond.stop()
 594                 self.exit_wait_cond = False
 595
 596         def makeConfig(self):
 597                 self.loadConfig()
 598                 self.devices_string = ""
 599                 self.devices = eConsoleAppContainer()
 600                 self.devices.dataAvail.append(self.callbackDevicesDataAvail)
 601                 self.devices.appClosed.append(self.callbakcDevicesAppClose)
 602                 self.devices.execute(_("cat /proc/bus/input/devices"))
 603
 604         def callbackDevicesDataAvail(self, ret_data):
 605                 self.devices_string = self.devices_string + ret_data
 606
 607         def callbakcDevicesAppClose(self, retval):
 608                 self.name_list  = []
 609                 self.mouse_list = None
 610                 self.keyboard_list = None
 611
 612                 self.makeHandlerList(self.devices_string)
 613
 614                 if self.conf_mouse == "" or self.getHandlerName(self.conf_mouse) is None:
 615                         self.conf_mouse = self.mouse_list[0][0]
 616                 self.mouse = ConfigSelection(default = self.conf_mouse, choices = self.mouse_list)
 617                 self.list.append(getConfigListEntry(_('Mouse'), self.mouse))
 618
 619                 if self.conf_keyboard == "" or self.getHandlerName(self.conf_keyboard) is None:
 620                         self.conf_keyboard = self.keyboard_list[0][0]
 621                 self.keyboard = ConfigSelection(default = self.conf_keyboard, choices = self.keyboard_list)
 622                 self.list.append(getConfigListEntry(_('Keyboard'), self.keyboard))
 623
 624                 if self.conf_keymap == "":
 625                         self.conf_keymap = self.getLanguage()
 626                 self.lang_list = [("rc_en", "English(RC)"), ("rc_ch", "German(RC)"), ("en", "English"), ("ch", "German")]
 627                 self.langs = ConfigSelection(default = self.conf_keymap, choices = self.lang_list)
 628                 self.list.append(getConfigListEntry(_("    - Type"), self.langs))
 629
 630                 if self.conf_alpha == "":
 631                         self.conf_alpha = "255"
 632                 self.alpha = ConfigSlider(default = int(self.conf_alpha), increment = 10, limits = (0, 255))
 633                 self.list.append(getConfigListEntry(_("Alpha Value"), self.alpha))
 634                 self["config"].list = self.list
 635                 self["config"].l.setList(self.list)
 636
 637         def getLanguage(self, lang=language.getLanguage()):
 638                 if self.current_lang_idx == 1:
 639                         return "rc_ch"
 640                 return "rc_en"
 641
 642         def makeHandlerList(self, data):
 643                 n = ""
 644                 p = ""
 645                 h_list = []
 646
 647                 event_list = []
 648                 lines = data.split('\n')
 649                 for line in lines:
 650                         print ">>", line
 651                         if line is not None and len(line) > 0:
 652                                 if line[0] == 'I':
 653                                         n = ""
 654                                         p = ""
 655                                         h_list = []
 656                                 elif line[0] == 'N':
 657                                         n = line[8:].strip()
 658                                 elif line[0] == 'P':
 659                                         p = line[8:].strip()
 660                                 elif line[0] == 'H':
 661                                         h_list = line[12:].strip().split()
 662                                         tn = line[12:].strip().find("mouse")
 663                                         for h in h_list:
 664                                                 event_list.append((h, _(h)))
 665                                                 self.name_list.append((h, n))
 666                                                 if n[1:].startswith("dream") and self.rc_mouse is None:
 667                                                         for thl in h.split(" "):
 668                                                                 if thl.startswith("event"):
 669                                                                         self.rc_mouse = copy.deepcopy(h)
 670                                                                         self.rc_keyboard = copy.deepcopy(h)
 671                                                                         print "detected!! rc:", h
 672                                                         continue
 673                                                 if h.startswith("mouse") and self.usb_mouse is None:
 674                                                         self.usb_mouse = copy.deepcopy(h)
 675                                                         print "detected!! usb mouse:",h
 676                                                         continue
 677                                                 if tn == -1 and self.usb_keyboard is None:
 678                                                         self.usb_keyboard = copy.deepcopy(h)
 679                                                         print "detected!! usb keyboard:",h
 680                                 elif line[0] == 'B' and line[3:].startswith("ABS") and p.startswith("usb-"):
 681                                         for h in h_list:
 682                                                 if self.usb_mouse is not None:
 683                                                         break
 684                                                 if self.usb_keyboard is not None and h == self.usb_keyboard[0]:
 685                                                         self.usb_keyboard = None
 686                                                         print "clean!! usb keyboard:",h
 687                                                 self.usb_mouse = copy.deepcopy(h)
 688                                                 print "detected!! usb mouse:",h
 689
 690                 tmp = copy.deepcopy(event_list)
 691                 if self.usb_mouse is not None:
 692                         tmp.insert(0, ("musb", "USB Mouse"))
 693                 if self.rc_mouse is not None:
 694                         tmp.insert(0, ("mrc", "Remote Control"))
 695                 self.mouse_list = tmp
 696
 697                 tmp = copy.deepcopy(event_list)
 698                 if self.usb_keyboard is not None:
 699                         tmp.insert(0, ("kusb", "USB Keyboard"))
 700                 if self.rc_keyboard is not None:
 701                         tmp.insert(0, ("krc", "Remote Control"))
 702                 self.keyboard_list = tmp
 703                 print "E:", event_list
 704                 print "M:", self.mouse_list
 705                 print "K:", self.keyboard_list
 706
 707         def startBrowser(self):
 708                 self.timer_start.stop()
 709
 710                 self.lock = True
 711                 excute_cmd("killall -15 %s"%(self.browser_name))
 712                 excute_cmd("echo 0 > /proc/sys/vm/swappiness")
 713
 714                 kbd_cmd = " "
 715                 mouse_cmd = " "
 716                 extra_cmd = "export VU_DOWNLOAD_DIR=/tmp; "
 717                 browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)
 718
 719                 mouse_param = self.mouse.value
 720                 if self.mouse.value == "mrc":
 721                         mouse_param = self.rc_mouse
 722                 elif self.mouse.value == "musb":
 723                         mouse_param = self.usb_mouse
 724                 keyboard_param = self.keyboard.value
 725                 if self.keyboard.value == "krc":
 726                         keyboard_param = self.rc_keyboard
 727                 elif self.keyboard.value == "kusb":
 728                         keyboard_param = self.usb_keyboard
 729
 730                 if self.getHandlerName(mouse_param)[1:].startswith("dreambox"):
 731                         enable_rc_mouse(True) #rc-mouse on
 732                 if str(mouse_param).startswith("event"):
 733                         mouse_cmd = "export QWS_MOUSE_PROTO=LinuxInput:/dev/input/%s; " % (str(mouse_param))
 734
 735                 keymap_param = ""
 736                 if self.langs.value == "ch":
 737                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/ch.qmap"
 738                 elif self.langs.value == "rc_ch":
 739                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/de.qmap"
 740                 elif self.langs.value == "rc_en":
 741                         keymap_param = ":keymap=/usr/share/keymaps/vuplus/us.qmap"
 742
 743                 kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s%s; " % (str(keyboard_param), keymap_param)
 744
 745                 cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
 746                 print "prepared command : [%s]" % cmd
 747
 748                 self.launcher = eConsoleAppContainer()
 749                 self.launcher.appClosed.append(self.callbackLauncherAppClosed)
 750                 self.launcher.dataAvail.append(self.callbackLauncherDataAvail)
 751
 752                 fbClass.getInstance().lock()
 753                 #eRCInput.getInstance().lock()
 754
 755                 global alpha_value
 756                 alpha_value = self.alpha.value
 757                 change_galpha(set_const=True, set_value=True)
 758
 759                 self.launcher.execute(cmd)
 760                 print "started browser..."
 761
 762         def keyGo(self):
 763                 self.saveConfig()
 764                 self.info.setText("Starting Webbrowser. Please wait...")
 765                 if self.lock == False:
 766                         if self.langs.value == "ch" or self.langs.value == "rc_ch":
 767                                 language.activateLanguageIndex(1)
 768                         else:
 769                                 language.activateLanguageIndex(0)
 770                         self.timer_start = eTimer()
 771                         self.timer_start.callback.append(self.startBrowser)
 772                         self.timer_start.start(10)
 773
 774         def getHandlerName(self, v):
 775                 if v == "mrc":
 776                         v = self.rc_mouse
 777                 elif v == "musb":
 778                         v = self.usb_mouse
 779                 elif v == "krc":
 780                         v = self.rc_keyboard
 781                 elif v == "kusb":
 782                         v = self.usb_keyboard
 783                 for l in self.name_list:
 784                         if l[0] == v:
 785                                 return l[1]
 786                 return None
 787
 788         def callbackLauncherDataAvail(self, ret_data):
 789                 print ret_data
 790                 if ret_data.startswith("--done--"):
 791                         self.lock = False
 792                         self.doExit()
 793
 794         def callbackLauncherAppClosed(self, retval = 1):
 795                 self.lock = False
 796
 797 def sessionstart(session, **kwargs):
 798         enable_rc_mouse(False)
 799         change_galpha(set_const=False, set_value=True)
 800         excute_cmd("killall -15 arora")
 801
 802 def main(session, **kwargs):
 803         session.open(BrowserLauncher)
 804
 805 def Plugins(**kwargs):
 806         return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, needsRestart = False, fnc=sessionstart),
 807                 PluginDescriptor(name=_("Web Browser"), description="start web browser", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)]
 808
 809