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