[SatipClient] Add new plugin.
[vuplus_dvbapp] / lib / python / Plugins / Extensions / WebBrowser / plugin.py
index 228db99..48cea21 100644 (file)
@@ -1,6 +1,6 @@
 from Plugins.Plugin import PluginDescriptor
 
 from Plugins.Plugin import PluginDescriptor
 
-import time, os, socket, thread
+import time, os, socket, thread, socket, copy
 from socket import gaierror, error
 from os import path as os_path, remove as os_remove
 
 from socket import gaierror, error
 from os import path as os_path, remove as os_remove
 
@@ -16,46 +16,89 @@ from urllib import quote, unquote_plus, unquote
 from urllib2 import Request, URLError, urlopen as urlopen2
 from httplib import HTTPConnection, CannotSendRequest, BadStatusLine, HTTPException
 
 from urllib2 import Request, URLError, urlopen as urlopen2
 from httplib import HTTPConnection, CannotSendRequest, BadStatusLine, HTTPException
 
+from Screens.Screen import Screen
+from Screens.ChoiceBox import ChoiceBox
+from Screens.MessageBox import MessageBox
+from Screens.DefaultWizard import DefaultWizard
+from Screens.InfoBarGenerics import InfoBarNotifications
+
 from Components.Button import Button
 from Components.Label import Label
 from Components.Button import Button
 from Components.Label import Label
-from Components.Pixmap import Pixmap
+from Components.Pixmap import Pixmap, MovingPixmap
+from Components.Language import language
 from Components.Sources.List import List
 from Components.ConfigList import ConfigListScreen
 from Components.Sources.StaticText import StaticText
 from Components.ActionMap import NumberActionMap, ActionMap
 from Components.ServiceEventTracker import ServiceEventTracker
 from Components.Sources.List import List
 from Components.ConfigList import ConfigListScreen
 from Components.Sources.StaticText import StaticText
 from Components.ActionMap import NumberActionMap, ActionMap
 from Components.ServiceEventTracker import ServiceEventTracker
-from Components.config import config, ConfigSelection, getConfigListEntry
+from Components.config import config, ConfigSelection, getConfigListEntry, ConfigSlider
 
 
-from Screens.Screen import Screen
-from Screens.ChoiceBox import ChoiceBox
-from Screens.MessageBox import MessageBox
-from Screens.DefaultWizard import DefaultWizard
-from Screens.InfoBarGenerics import InfoBarNotifications
+from Tools.Directories import resolveFilename, SCOPE_PLUGINS
+from Tools.LoadPixmap import LoadPixmap
 
 
-from enigma import eTimer, eServiceReference, iPlayableService, fbClass, eRCInput, eConsoleAppContainer
+from enigma import eTimer, eServiceReference, iPlayableService, fbClass, eRCInput, eConsoleAppContainer, getDesktop, ePicLoad
 
 HTTPConnection.debuglevel = 1
 
 
 HTTPConnection.debuglevel = 1
 
+def excute_cmd(cmd):
+       print "prepared cmd:", cmd
+       os.system(cmd)
+
+alpha_value = 0
+def change_galpha(set_const, set_value):
+       op  = "/proc/stb/fb/alpha_op"
+       val = "/proc/stb/fb/alpha_value"
+       global alpha_value
+       if os.path.exists(op) and set_const and alpha_value < 255:
+               excute_cmd("echo \"const\" > %s" % (op))
+       else:
+               excute_cmd("echo \"copypsrc\" > %s" % (op))
+
+       if os.path.exists(val) and set_value:
+               excute_cmd("echo \"%s\" > %s" % (str(hex(alpha_value)), val))
+
+def enable_rc_mouse(mode): #mode=[0|1]|[False|True]
+       mouse_cond = "/proc/stb/fp/mouse"
+       if os.path.exists(mouse_cond):
+               excute_cmd("echo %d > %s" % (mode, mouse_cond))
+
+def is_process_running(pname):
+       if pname is None or len(pname) == 0:
+               return False
+
+       cmd = "/bin/ps -ef | grep %s | grep -v grep | awk \'{print $5}\'"%(pname)
+       for line in os.popen(cmd).readlines():
+               return True
+       return False
+
 lock = False
 lock = False
-def player_lock():
+def wb_lock(alpha_on=True):
        global lock
        lock = True
        global lock
        lock = True
+       if alpha_on:
+               change_galpha(set_const=False, set_value=False)
        fbClass.getInstance().unlock()
 
        fbClass.getInstance().unlock()
 
-def player_unlock():
+def wb_unlock(alpha_on=True):
        global lock
        global lock
+       if alpha_on:
+               change_galpha(set_const=True, set_value=False)
        fbClass.getInstance().lock()
        lock = False
 
        fbClass.getInstance().lock()
        lock = False
 
-def player_islock():
+def wb_islock():
        global lock
        return lock
 
 class VuPlayer(Screen, InfoBarNotifications):
        global lock
        return lock
 
 class VuPlayer(Screen, InfoBarNotifications):
+       size = getDesktop(0).size()
+       wb_bgr = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/mp_wb_background.png")
+       wb_btn = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/mp_wb_buttons.png")
+       position_params = size.width() > 750 and (620, wb_bgr, wb_btn) or (480, wb_bgr, wb_btn)
        skin =  """
        skin =  """
-               <screen name="VuPlayer" flags="wfNoBorder" position="center,620" size="455,53" title="VuPlayer" backgroundColor="transparent">
-                       <ePixmap pixmap="Vu_HD/mp_wb_background.png" position="0,0" zPosition="-1" size="455,53" />
-                       <ePixmap pixmap="Vu_HD/icons/mp_wb_buttons.png" position="40,23" size="30,13" alphatest="on" />
+               <screen name="VuPlayer" flags="wfNoBorder" position="center,%d" size="455,53" title="VuPlayer" backgroundColor="transparent">
+                       <ePixmap pixmap="%s" position="0,0" zPosition="-1" size="455,53" />
+                       <ePixmap pixmap="%s" position="40,23" size="30,13" alphatest="on" />
 
                        <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">
                                <convert type="ServicePosition">Gauge</convert>
 
                        <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">
                                <convert type="ServicePosition">Gauge</convert>
@@ -69,7 +112,8 @@ class VuPlayer(Screen, InfoBarNotifications):
                                <convert type="ServicePosition">Length</convert>
                        </widget>
                </screen>
                                <convert type="ServicePosition">Length</convert>
                        </widget>
                </screen>
-               """
+               """ % position_params
+
        PLAYER_IDLE     = 0
        PLAYER_PLAYING  = 1
        PLAYER_PAUSED   = 2
        PLAYER_IDLE     = 0
        PLAYER_PLAYING  = 1
        PLAYER_PAUSED   = 2
@@ -107,6 +151,7 @@ class VuPlayer(Screen, InfoBarNotifications):
                self.onClose.append(self.__onClose)
                self.doPlay()
 
                self.onClose.append(self.__onClose)
                self.doPlay()
 
+
        def __onClose(self):
                self.session.nav.stopService()
 
        def __onClose(self):
                self.session.nav.stopService()
 
@@ -128,13 +173,14 @@ class VuPlayer(Screen, InfoBarNotifications):
                self.hidetimer.start(5000)
 
        def doExit(self):
                self.hidetimer.start(5000)
 
        def doExit(self):
+               message = "Stop playing this movie?"
                list = ((_("Yes"), "y"), (_("No, but play video again"), "n"),)
                list = ((_("Yes"), "y"), (_("No, but play video again"), "n"),)
-               self.session.openWithCallback(self.cbDoExit, ChoiceBox, title=_("Stop playing this movie?"), list = list)
+               self.session.openWithCallback(self.cbDoExit, ChoiceBox, title=_(message), list = list)
 
        def cbDoExit(self, answer):
                answer = answer and answer[1]
                if answer == "y":
 
        def cbDoExit(self, answer):
                answer = answer and answer[1]
                if answer == "y":
-                       player_unlock()
+                       wb_unlock()
                        self.close()
                elif answer == "n":
                        if self.state != self.PLAYER_IDLE:
                        self.close()
                elif answer == "n":
                        if self.state != self.PLAYER_IDLE:
@@ -204,6 +250,29 @@ std_headers = {
 }
 
 class VuPlayerLauncher:
 }
 
 class VuPlayerLauncher:
+       QUALITY_CODE =  {
+                        '5': 'FLV 224p'
+                       ,'6': 'FLV 270p'
+                       ,'34':'FLV 360p'
+                       ,'35':'FLV 480p'
+                       ,'18':'MP4 360p'
+                       ,'22':'MP4 720p'
+                       ,'37':'MP4 1080p'
+                       ,'38':'MP4 2304p'
+                       ,'83':'MP4-3D 240p'
+                       ,'82':'MP4-3D 360p'
+                       ,'85':'MP4-3D 520p'
+                       ,'84':'MP4-3D 720p'
+                       ,'43':'WebM 360p'
+                       ,'44':'WebM 480p'
+                       ,'45':'WebM 720p'
+                       ,'46':'WebM 1080p'
+                       ,'100':'WebM-3D 360p'
+                       ,'101':'WebM-3D 480p'
+                       ,'102':'WebM-3D 720p'
+                       ,'13':'3GP 0.5'
+                       ,'17':'3GP 2.0'
+                       }
        def getVideoUrl(self, video_id):
                video_url = None
 
        def getVideoUrl(self, video_id):
                video_url = None
 
@@ -248,35 +317,74 @@ class VuPlayerLauncher:
                else:
                        tmp_fmtUrlDATA = videoinfo['fmt_url_map'][0].split(',')
                for fmtstring in tmp_fmtUrlDATA:
                else:
                        tmp_fmtUrlDATA = videoinfo['fmt_url_map'][0].split(',')
                for fmtstring in tmp_fmtUrlDATA:
+                       num_fmtid = 0
                        if videoinfo.has_key('url_encoded_fmt_stream_map'):
                                (fmturl, fmtid) = fmtstring.split('&itag=')
                        if videoinfo.has_key('url_encoded_fmt_stream_map'):
                                (fmturl, fmtid) = fmtstring.split('&itag=')
+                               try:
+                                       num_fmtid = int(fmtid)
+                               except: 
+                                       try:
+                                               num_fmtid = int(fmtid[:fmtid.find(',')])
+                                       except: pass
+                                       pass
+
                                if fmturl.find("url=") !=-1:
                                        fmturl = fmturl.replace("url=","")
                        else:
                                (fmtid,fmturl) = fmtstring.split('|')
                        if VIDEO_FMT_PRIORITY_MAP.has_key(fmtid):
                                video_fmt_map[VIDEO_FMT_PRIORITY_MAP[fmtid]] = { 'fmtid': fmtid, 'fmturl': unquote_plus(fmturl) }
                                if fmturl.find("url=") !=-1:
                                        fmturl = fmturl.replace("url=","")
                        else:
                                (fmtid,fmturl) = fmtstring.split('|')
                        if VIDEO_FMT_PRIORITY_MAP.has_key(fmtid):
                                video_fmt_map[VIDEO_FMT_PRIORITY_MAP[fmtid]] = { 'fmtid': fmtid, 'fmturl': unquote_plus(fmturl) }
-                       fmt_infomap[int(fmtid)] = unquote_plus(fmturl)
-               print "got",sorted(fmt_infomap.iterkeys())
-               if video_fmt_map and len(video_fmt_map):
-                       video_url = video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmturl'].split(';')[0]
-                       #print "found best available video format:",video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmtid']
-                       #print "found best available video url:",video_url
-               return video_url
+                       if num_fmtid:
+                               fmt_infomap[num_fmtid] = unquote_plus(fmturl)
+               print "fmtinfomap :",sorted(fmt_infomap.iterkeys())
+       
+               video_url_list = []
+               if video_fmt_map:
+                       idx = 0
+                       sorted_fmt_keys = sorted(video_fmt_map.iterkeys())
+                       for x in video_fmt_map:
+                               try:
+                                       videofmt    = video_fmt_map[sorted_fmt_keys[idx]]
+                                       video_url   = videofmt['fmturl'].split(';')[0]
+                                       quality_str = self.qCode2String(videofmt['fmtid'])
+                                       #print "detected video : quality [%s], url [%s]" % (quality_str, video_url)
+                                       if video_url and quality_str:
+                                               video_url_list.append((quality_str, video_url))
+                                               print "added quality [%s], url [%s]" % (quality_str, video_url)
+                               except Exception, msg: print "Error >>", msg
+                               idx = idx + 1
+               return video_url_list
+
+       def qCode2String(self, qcode):
+               qstr = None
+               try:
+                       qstr = self.QUALITY_CODE[qcode]
+               except: pass 
+               #print "quality : code[%s], str[%s]" % (qcode, qstr)
+               return qstr
 
        def run(self, tubeid, session, service):
 
        def run(self, tubeid, session, service):
+               self.session = session
+               self.service = service
                try:
                try:
-                       myurl = self.getVideoUrl(tubeid)
-                       print "Playing URL", myurl
-                       if myurl is None:
+                       self.url_list = self.getVideoUrl(tubeid)
+                       if self.url_list is None or len(self.url_list) == 0:
                                session.open(MessageBox, _("Sorry, video is not available!"), MessageBox.TYPE_INFO)
                                session.open(MessageBox, _("Sorry, video is not available!"), MessageBox.TYPE_INFO)
+                               wb_unlock()
                                return
                                return
+                       titlemsg = "Please, choice video quality.\nFor smooth playback depends on network conditions."
+                       self.session.openWithCallback(self.cbSelectedQuality, ChoiceBox, title=_(titlemsg), list = self.url_list)
+               except Exception, msg:
+                       wb_unlock()
+                       print "Error >>", msg
 
 
-                       player_lock()
-                       myreference = eServiceReference(4097, 0, myurl)
-                       session.open(VuPlayer, myreference, service)
+       def cbSelectedQuality(self, choice):
+               try:
+                       print "selected [%s] : [%s]" % (choice[0], choice[1])
+                       myreference = eServiceReference(4097, 0, choice[1])
+                       self.session.open(VuPlayer, myreference, self.service)
                except Exception, msg:
                except Exception, msg:
-                       player_unlock()
+                       wb_unlock()
                        print "Error >>", msg
 
 class VuPlayerService:
                        print "Error >>", msg
 
 class VuPlayerService:
@@ -304,6 +412,7 @@ class VuPlayerService:
        def run(self, e = True):
                if self.enable:
                        return
        def run(self, e = True):
                if self.enable:
                        return
+               print "VuPlayerService start!!"
                self.enable = e
                self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
                self.sock.settimeout(self.socket_timeout)
                self.enable = e
                self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
                self.sock.settimeout(self.socket_timeout)
@@ -313,76 +422,109 @@ class VuPlayerService:
                        try:
                                conn, addr = self.sock.accept()
                                self.parseHandle(conn, addr)
                        try:
                                conn, addr = self.sock.accept()
                                self.parseHandle(conn, addr)
-                               conn.close()
                        except socket.timeout:
                                #print "[socket timeout]"
                                pass
                        except socket.timeout:
                                #print "[socket timeout]"
                                pass
+               print "VuPlayerService stop!!"
 
        def parseHandle(self, conn, addr):
                # [http://www.youtube.com/watch?v=BpThu778qB4&feature=related]
                data = conn.recv(self.max_buffer_size)
 
        def parseHandle(self, conn, addr):
                # [http://www.youtube.com/watch?v=BpThu778qB4&feature=related]
                data = conn.recv(self.max_buffer_size)
-               print "[%s]" % (data) 
-               tmp = data.split("?")
-               print tmp # ['http://www.youtube.com/watch', 'v=BpThu778qB4&feature=related']
-               service = self.session.nav.getCurrentlyPlayingServiceReference()
-               if len(tmp) == 2 and tmp[0] == "http://www.youtube.com/watch":
-                       tmp = tmp[1].split("&")
-                       print tmp # ['v=BpThu778qB4', 'feature=related']
-                       if len(tmp) == 2:
-                               tmp = tmp[0].split("=")
-                               print tmp # ['v', 'BpThu778qB4']
-                               if len(tmp) == 2 and tmp[0] == "v":
-                                       player = VuPlayerLauncher()
-                                       player.run(tmp[1], self.session, service)
-                                       while player_islock():
-                                               time.sleep(1)
-                                       self.session.nav.playService(service)
-                                       data = "ok$"
+               print "[%s]" % (data)
+               enable_rc_mouse(False)
+               if data.startswith("http://www.youtube.com"):
+                       print "youtube start!!"
+                       tmp = data.split("?")
+                       print tmp # ['http://www.youtube.com/watch', 'v=BpThu778qB4&feature=related']
+                       service = self.session.nav.getCurrentlyPlayingServiceReference()
+                       if len(tmp) and tmp[0] == "http://www.youtube.com/watch":
+                               tmp = tmp[1].split("&")
+                               print tmp # ['v=BpThu778qB4', 'feature=related']
+                               if len(tmp):
+                                       tmp = tmp[0].split("=")
+                                       print tmp # ['v', 'BpThu778qB4']
+                                       if len(tmp) == 2 and tmp[0] == "v":
+                                               wb_lock()
+                                               player = VuPlayerLauncher()
+                                               player.run(tmp[1], self.session, service)
+                                               while wb_islock():
+                                                       time.sleep(1)
+                                               self.session.nav.playService(service)
+                                               data = "ok$"
+                                       else:
+                                               data = "nok$parsing fail"
                                else:
                                        data = "nok$parsing fail"
                        else:
                                data = "nok$parsing fail"
                                else:
                                        data = "nok$parsing fail"
                        else:
                                data = "nok$parsing fail"
-               else:
-                       data = "nok$parsing fail"
+                       self.sendResponse(conn, data)
+               elif data.startswith("vk://open"):
+                       print "virtual keyboard start!!"
+                       from Screens.VirtualKeyBoard import VirtualKeyBoard
+                       wb_lock()
+                       self.vk_conn = conn
+                       self.session.openWithCallback(self.cbOpenKeyboard, VirtualKeyBoard, title = (_("Enter your input data")), text = "")
+
+        def cbOpenKeyboard(self, data = None):
+               print "virtual keyboard callback!!"
+               wb_unlock()
+               self.sendResponse(self.vk_conn, data)
+               
+       def sendResponse(self, conn, data):
+               if data is None or len(data) == 0:
+                       data = ""
+               enable_rc_mouse(True)
                conn.send(data)
                conn.send(data)
+               conn.close()
 
 class BrowserLauncher(ConfigListScreen, Screen):
        skin=   """
 
 class BrowserLauncher(ConfigListScreen, Screen):
        skin=   """
-               <screen name="BrowserLauncher" position="center,center" size="300,160" title="Web Browser">
-                       <ePixmap pixmap="Vu_HD/buttons/red.png" position="50,0" size="140,40" alphatest="on" />
-                       <ePixmap pixmap="Vu_HD/buttons/green.png" position="170,0" size="140,40" alphatest="on" />
-                       <widget source="key_red" render="Label" position="50,0" zPosition="1" size="115,30" font="Regular;20" halign="center" valign="center" transparent="1" />
-                       <widget source="key_green" render="Label" position="170,0" zPosition="1" size="115,30" font="Regular;20" halign="center" valign="center" transparent="1" />
-                       <widget name="config" position="0,50" size="300,70" scrollbarMode="showOnDemand" />
-                       <widget name="introduction" position="0,120" size="300,40" font="Regular;20" halign="center" backgroundColor="#a08500" transparent="1" />
+               <screen position="center,center" size="623,300" title="Web Browser">
+                       <ePixmap pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" />
+                       <ePixmap pixmap="skin_default/buttons/green.png" position="158,0" size="140,40" alphatest="on" />
+
+                       <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" />
+                       <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" />
+
+                       <widget name="config" position="0,50" size="309,100" scrollbarMode="showOnDemand" />
+                       <ePixmap pixmap="rc_wb_desc.png" position="312,5" size="309,296" alphatest="on" />
+                       <widget name="info" position="0,180" size="309,50" font="Regular;18" halign="center" foregroundColor="#a08500" transparent="1" />
                </screen>
                """
                </screen>
                """
+
        def __init__(self, session): 
                Screen.__init__(self, session)
        def __init__(self, session): 
                Screen.__init__(self, session)
+               
+
                 self.session = session
                 self.session = session
+               self.list = []
+               ConfigListScreen.__init__(self, self.list)
 
                self.browser_root = "/usr/bin"
                self.browser_name = "arora"
 
                self.browser_root = "/usr/bin"
                self.browser_name = "arora"
-               self.mouse_cond = "/proc/stb/fp/mouse"
+
+               from Tools.Directories import resolveFilename, SCOPE_PLUGINS
+               self.conf_file = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/settings.conf")
                self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
                 {      "red": self.keyCancel,
                self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
                 {      "red": self.keyCancel,
-                       "cancel": self.keyCancel,
                        "green": self.keyGo,
                        "green": self.keyGo,
+                       "cancel": self.keyExit,
                 }, -2)
                 }, -2)
-
-               self.list = []
-               ConfigListScreen.__init__(self, self.list)
-
+               self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
+               self["info"] = self.info
                self["key_red"] = StaticText(_("Exit"))
                self["key_green"] = StaticText(_("Start"))
                self["key_red"] = StaticText(_("Exit"))
                self["key_green"] = StaticText(_("Start"))
-               self.introduntion = Label(_(" "))
-               self["introduction"] = self.introduntion
 
 
-               self.devices_string = ""
-               self.mouse_choice_list = []
-               self.mouse_device_list = []
-               self.keyboard_choice_list = []
-               self.keyboard_device_list = []
+               self.conf_alpha = ""
+               self.conf_mouse = ""
+               self.conf_keyboard = ""
+               self.conf_keymap = ""
+
+               self.usb_mouse = None
+               self.usb_keyboard = None
+               self.rc_mouse = None
+               self.rc_keyboard = None
+
                self.makeConfig()
                #time.sleep(2)
 
                self.makeConfig()
                #time.sleep(2)
 
@@ -390,30 +532,82 @@ class BrowserLauncher(ConfigListScreen, Screen):
                self.vu_service = VuPlayerService(self.session)
                self.vu_service.start(timeout=5)
 
                self.vu_service = VuPlayerService(self.session)
                self.vu_service.start(timeout=5)
 
-       def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
-               if os.path.exists(self.mouse_cond):
-                       self.cmd("echo %d > %s" % (mode, self.mouse_cond))
+               self.exit_wait_cond = False
+               self.timer_exit_cond = eTimer()
+               self.timer_exit_cond.callback.append(self.resetExitCond)
 
 
-       def cmd(self, cmd):
-               print "prepared cmd:", cmd
-               os.system(cmd)
+               self.test_cond = True
+               self.current_lang_idx = language.getActiveLanguageIndex()
 
        def keyNone(self):
                None
 
 
        def keyNone(self):
                None
 
+       def doExit(self):
+               change_galpha(set_const=False, set_value=False)
+               self.saveConfig()
+               self.vu_service.stop()
+               excute_cmd("killall -15 %s"%(self.browser_name))
+               excute_cmd("echo 60 > /proc/sys/vm/swappiness")
+               enable_rc_mouse(False) #rc-mouse off
+               language.activateLanguageIndex(self.current_lang_idx)
+               fbClass.getInstance().unlock()
+               #eRCInput.getInstance().unlock()
+               self.close()
+
+       def keyExit(self):
+               if self.exit_wait_cond:
+                       self.doExit()
+               if is_process_running(self.browser_name) == False:
+                       self.doExit()
+
+       def keyLeft(self):
+               if is_process_running(self.browser_name) == False:
+                       ConfigListScreen.keyLeft(self)
+                       global alpha_value
+                       alpha_value = self.alpha.value
+                       #self.saveConfig()
+
+       def keyRight(self):
+               if is_process_running(self.browser_name) == False:
+                       ConfigListScreen.keyRight(self)
+                       alpha_value = self.alpha.value
+                       #self.saveConfig()
+
        def keyCancel(self):
        def keyCancel(self):
-               #if self.lock == False:
-                       self.vu_service.stop()
-                       self.cmd("killall -9 %s"%(self.browser_name))
-                       self.cmd("echo 60 > /proc/sys/vm/swappiness")
-                       self.introduntion.setText(" ")
-                       if self.mouse.value == 0:
-                               self.enableRCMouse(False) #rc-mouse off
-                       fbClass.getInstance().unlock()
-                       #eRCInput.getInstance().unlock()
-                       self.close()
+               if is_process_running(self.browser_name) == False:
+                       self.doExit()
+               self.exit_wait_cond = True
+               self.timer_exit_cond.start(5000)
+
+       # mouse:keyboard:alpha_value
+       def saveConfig(self):
+               if is_process_running(self.browser_name) == False:
+                       command = "echo \"%s:%s:%d:%s\" > %s"%(self.mouse.value, self.keyboard.value, int(self.alpha.value), self.langs.value, self.conf_file)
+                       excute_cmd(command)
+
+       # mouse:keyboard:alpha_value
+       def loadConfig(self):
+               if os.path.exists(self.conf_file) == False:
+                       return
+               config_list = open(self.conf_file).readline().strip().split(':')
+               if len(config_list) == 3:
+                       self.conf_mouse         = config_list[0]
+                       self.conf_keyboard      = config_list[1]
+                       self.conf_alpha         = config_list[2]
+               elif len(config_list) == 4:
+                       self.conf_mouse         = config_list[0]
+                       self.conf_keyboard      = config_list[1]
+                       self.conf_alpha         = config_list[2]
+                       self.conf_keymap        = config_list[3]
+               print "load config : ", config_list
+
+       def resetExitCond(self):
+               self.timer_exit_cond.stop()
+               self.exit_wait_cond = False
 
        def makeConfig(self):
 
        def makeConfig(self):
+               self.loadConfig()
+               self.devices_string = ""
                self.devices = eConsoleAppContainer()
                self.devices.dataAvail.append(self.callbackDevicesDataAvail)
                self.devices.appClosed.append(self.callbakcDevicesAppClose)
                self.devices = eConsoleAppContainer()
                self.devices.dataAvail.append(self.callbackDevicesDataAvail)
                self.devices.appClosed.append(self.callbakcDevicesAppClose)
@@ -423,164 +617,205 @@ class BrowserLauncher(ConfigListScreen, Screen):
                self.devices_string = self.devices_string + ret_data
 
        def callbakcDevicesAppClose(self, retval):
                self.devices_string = self.devices_string + ret_data
 
        def callbakcDevicesAppClose(self, retval):
-               self.parseDeviceData(self.devices_string)
-               self.makeHandlerList()
-
-               # none : -1, rc : 0, usb : 1
-               self.mouse_choice_list.append((2, _("None")))
-               self.keyboard_choice_list.append((2, _("None")))
+               self.name_list  = []
+               self.mouse_list = None
+               self.keyboard_list = None
                
                
-               print self.mouse_choice_list
-               print self.keyboard_choice_list
-               print self.mouse_device_list
-               print self.keyboard_device_list
+               self.makeHandlerList(self.devices_string)
 
 
-               self.mouse = ConfigSelection(default = self.mouse_choice_list[0][0], choices = self.mouse_choice_list)
-               self.keyboard = ConfigSelection(default = self.mouse_choice_list[0][0], choices = self.keyboard_choice_list)
-               
+               if self.conf_mouse == "" or self.getHandlerName(self.conf_mouse) is None:
+                       self.conf_mouse = self.mouse_list[0][0]
+               self.mouse = ConfigSelection(default = self.conf_mouse, choices = self.mouse_list)
                self.list.append(getConfigListEntry(_('Mouse'), self.mouse))            
                self.list.append(getConfigListEntry(_('Mouse'), self.mouse))            
+               
+               if self.conf_keyboard == "" or self.getHandlerName(self.conf_keyboard) is None:
+                       self.conf_keyboard = self.keyboard_list[0][0]
+               self.keyboard = ConfigSelection(default = self.conf_keyboard, choices = self.keyboard_list)
                self.list.append(getConfigListEntry(_('Keyboard'), self.keyboard))
                self.list.append(getConfigListEntry(_('Keyboard'), self.keyboard))
+
+               if self.conf_keymap == "":
+                       self.conf_keymap = self.getLanguage()
+               self.lang_list = [("rc_en", "English(RC)"), ("rc_ch", "German(RC)"), ("en", "English"), ("ch", "German")]
+               self.langs = ConfigSelection(default = self.conf_keymap, choices = self.lang_list)
+               self.list.append(getConfigListEntry(_("    - Type"), self.langs))
+
+               if self.conf_alpha == "":
+                       self.conf_alpha = "255"
+               self.alpha = ConfigSlider(default = int(self.conf_alpha), increment = 10, limits = (0, 255))
+               self.list.append(getConfigListEntry(_("Alpha Value"), self.alpha))
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
-       def parseDeviceData(self, data):
+       def getLanguage(self, lang=language.getLanguage()):
+               if self.current_lang_idx == 1:
+                       return "rc_ch"
+               return "rc_en"
+
+       def makeHandlerList(self, data):
                n = ""
                p = ""
                n = ""
                p = ""
-               h = ""
-               self.devices=[]
-               lines=data.split('\n')
-               for line in lines:
-                       if line == None or line == "":
-                               if h != None and len(h) != 0:
-                                       print "find driver >> name[%s], phys[%s], handler[%s]" % (n, p, h)
-                                       self.devices.append([n, p, h])
-                               n = ""
-                               p = ""
-                               h = ""
-                               continue
-                       if line[0] == 'N':
-                               n = line[8:].strip()
-                       elif line[0] == 'P':
-                               p = line[8:].strip()
-                       elif line[0] == 'H':
-                               h = line[12:].strip()
-
-       def makeHandlerList(self):
-               if self.devices == None or self.devices == []:
-                       return False
-
-               mouse_pc_h = []
-               mouse_rc_h = []
-               keyboard_pc_h = []
-               keyboard_rc_h = []
-               for dev in self.devices:
-                       n = dev[0]
-                       p = dev[1]
-                       h = dev[2]
-                       if p.startswith("usb-ohci-brcm"):
-                               if h.rfind("mouse") >= 0:
-                                       mouse_pc_h = [(1, _("USB Mouse")), self.getHandlerName(h, "mouse")]
-                               else:
-                                       if len(keyboard_pc_h) == 0:
-                                               keyboard_pc_h = [(1, _("USB Keyboard")), self.getHandlerName(h, "event")]
-                       else:
-                               if n[1:].startswith("dreambox") and os.path.exists(self.mouse_cond) :
-                                       mouse_rc_h    = [(0, _("RemoteControl")), self.getHandlerName(h, "event")]
-                                       keyboard_rc_h = [(0, _("RemoteControl")), self.getHandlerName(h, "event")]
-               if len(mouse_rc_h) > 0:
-                       self.mouse_choice_list.append(mouse_rc_h[0])
-                       self.mouse_device_list.append(mouse_rc_h[1])
-               if len(mouse_pc_h) > 0:
-                       self.mouse_choice_list.append(mouse_pc_h[0])
-                       self.mouse_device_list.append(mouse_pc_h[1])
-
-               if len(keyboard_rc_h) > 0:
-                       self.keyboard_choice_list.append(keyboard_rc_h[0])
-                       self.keyboard_device_list.append(keyboard_rc_h[1])
-               if len(keyboard_pc_h) > 0:
-                       self.keyboard_choice_list.append(keyboard_pc_h[0])
-                       self.keyboard_device_list.append(keyboard_pc_h[1])
-               return True
+               h_list = []
 
 
-       def getHandlerName(self, h, s):
-               if h is None or len(h) == 0:
-                       return ""
-
-               handles = h.split()                                                
-               #print "handles >> ", handles
-               for tmp_h in handles:                                                                                                    
-                       #print "handle_item >> ", tmp_h
-                       if tmp_h.startswith(s):          
-                               #print "detected : [%s]" % tmp_h
-                               return tmp_h
-               return ""
+               event_list = []
+               lines = data.split('\n')
+               for line in lines:
+                       print ">>", line
+                       if line is not None and len(line) > 0:
+                               if line[0] == 'I':
+                                       n = ""
+                                       p = ""
+                                       h_list = []
+                               elif line[0] == 'N':
+                                       n = line[8:].strip()
+                               elif line[0] == 'P':
+                                       p = line[8:].strip()
+                               elif line[0] == 'H':
+                                       h_list = line[12:].strip().split()
+                                       tn = line[12:].strip().find("mouse")
+                                       for h in h_list:
+                                               event_list.append((h, _(h)))
+                                               self.name_list.append((h, n))
+                                               if n[1:].startswith("dream") and self.rc_mouse is None:
+                                                       for thl in h.split(" "):
+                                                               if thl.startswith("event"):
+                                                                       self.rc_mouse = copy.deepcopy(h)
+                                                                       self.rc_keyboard = copy.deepcopy(h)
+                                                                       print "detected!! rc:", h
+                                                       continue
+                                               if h.startswith("mouse") and self.usb_mouse is None:
+                                                       self.usb_mouse = copy.deepcopy(h)
+                                                       print "detected!! usb mouse:",h
+                                                       continue
+                                               if tn == -1 and self.usb_keyboard is None:
+                                                       self.usb_keyboard = copy.deepcopy(h)
+                                                       print "detected!! usb keyboard:",h
+                               elif line[0] == 'B' and line[3:].startswith("ABS") and p.startswith("usb-"):
+                                       for h in h_list:
+                                               if self.usb_mouse is not None:
+                                                       break
+                                               if self.usb_keyboard is not None and h == self.usb_keyboard[0]:
+                                                       self.usb_keyboard = None
+                                                       print "clean!! usb keyboard:",h
+                                               self.usb_mouse = copy.deepcopy(h)
+                                               print "detected!! usb mouse:",h
+
+               tmp = copy.deepcopy(event_list)
+               if self.usb_mouse is not None:
+                       tmp.insert(0, ("musb", "USB Mouse"))
+               if self.rc_mouse is not None:
+                       tmp.insert(0, ("mrc", "Remote Control"))
+               self.mouse_list = tmp
+
+               tmp = copy.deepcopy(event_list)
+               if self.usb_keyboard is not None:
+                       tmp.insert(0, ("kusb", "USB Keyboard"))
+               if self.rc_keyboard is not None:
+                       tmp.insert(0, ("krc", "Remote Control"))
+               self.keyboard_list = tmp
+               print "E:", event_list
+               print "M:", self.mouse_list
+               print "K:", self.keyboard_list
+
+       def startBrowser(self):
+               self.timer_start.stop()
+
+               self.lock = True
+               excute_cmd("killall -15 %s"%(self.browser_name))
+               excute_cmd("echo 0 > /proc/sys/vm/swappiness")
+
+               kbd_cmd = " "
+               mouse_cmd = " "
+               extra_cmd = "export VU_DOWNLOAD_DIR=/tmp; " 
+               browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)
+
+               mouse_param = self.mouse.value
+               if self.mouse.value == "mrc":
+                       mouse_param = self.rc_mouse
+               elif self.mouse.value == "musb":
+                       mouse_param = self.usb_mouse
+               keyboard_param = self.keyboard.value
+               if self.keyboard.value == "krc":
+                       keyboard_param = self.rc_keyboard
+               elif self.keyboard.value == "kusb":
+                       keyboard_param = self.usb_keyboard
+
+               if self.getHandlerName(mouse_param)[1:].startswith("dreambox"):
+                       enable_rc_mouse(True) #rc-mouse on
+               if str(mouse_param).startswith("event"):
+                       mouse_cmd = "export QWS_MOUSE_PROTO=LinuxInput:/dev/input/%s; " % (str(mouse_param))
+
+               keymap_param = ""
+               if self.langs.value == "ch":
+                       keymap_param = ":keymap=/usr/share/keymaps/vuplus/ch.qmap"
+               elif self.langs.value == "rc_ch":
+                       keymap_param = ":keymap=/usr/share/keymaps/vuplus/de.qmap"
+               elif self.langs.value == "rc_en":
+                       keymap_param = ":keymap=/usr/share/keymaps/vuplus/us.qmap"
+
+               kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s%s; " % (str(keyboard_param), keymap_param)
+
+               cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
+               print "prepared command : [%s]" % cmd
+
+               self.launcher = eConsoleAppContainer()
+               self.launcher.appClosed.append(self.callbackLauncherAppClosed)
+               self.launcher.dataAvail.append(self.callbackLauncherDataAvail)
+
+               fbClass.getInstance().lock()
+               #eRCInput.getInstance().lock()
+
+               global alpha_value
+               alpha_value = self.alpha.value
+               change_galpha(set_const=True, set_value=True)
+
+               self.launcher.execute(cmd)
+               print "started browser..."
 
        def keyGo(self):
 
        def keyGo(self):
+               self.saveConfig()
+               self.info.setText("Starting Webbrowser. Please wait...")
                if self.lock == False:
                if self.lock == False:
-                       self.lock = True
-                       
-                       self.introduntion.setText("Run web-browser.\nPlease, wait...")
-                       self.cmd("echo 0 > /proc/sys/vm/swappiness")
-
-                       kbd_cmd = ""
-                       mouse_cmd = ""
-                       extra_cmd = "" 
-                       browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)
-
-                       fbClass.getInstance().lock()
-                       #eRCInput.getInstance().lock()
-
-                       if self.mouse.value == 0:
-                               self.enableRCMouse(True) #rc-mouse on
-                               idx = self.getListIndex(self.mouse_choice_list, 0)
-                               mouse_cmd = "export QWS_MOUSE_PROTO=LinuxInput:/dev/input/%s; " % (self.mouse_device_list[idx])
-                       elif self.mouse.value == 1:
-                               mouse_cmd = " "
-                               #mouse_cmd = "export QWS_MOUSE_PROTO=Auto:/dev/input/%s; " % (m)
-                       elif self.mouse.value == 2:
-                               mouse_cmd = "export QWS_MOUSE_PROTO=None; "
-
-                       if self.keyboard.value == 0:
-                               idx = self.getListIndex(self.keyboard_choice_list, 0)
-                               kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s; " % (self.keyboard_device_list[idx])
-                       elif self.keyboard.value == 1:
-                               idx = self.getListIndex(self.keyboard_choice_list, 1)
-                               kbd_cmd = "export QWS_KEYBOARD=LinuxInput:/dev/input/%s; " % (self.keyboard_device_list[idx])
-                       elif self.keyboard.value == 2:
-                               kbd_cmd = " "
-                       print "mouse cmd >>", mouse_cmd, " >> ", self.mouse.value
-                       print "keyboard cmd >>", kbd_cmd, " >> ", self.keyboard.value
-
-                       cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
-                       print "prepared command : [%s]" % cmd
-
-                       self.launcher = eConsoleAppContainer()
-                       self.launcher.appClosed.append(self.callbackLauncherAppClosed)
-                       self.launcher.dataAvail.append(self.callbackLauncherDataAvail)
-                       self.launcher.execute(cmd)
-                       print "running arora..."
-
-       def getListIndex(self, l, v):
-               idx = 0
-               for i in l:
-                       if i[0] == v:
-                               return idx;
-                       idx = idx + 1
-               return -1
+                       if self.langs.value == "ch" or self.langs.value == "rc_ch":
+                               language.activateLanguageIndex(1)
+                       else:
+                               language.activateLanguageIndex(0)
+                       self.timer_start = eTimer()
+                       self.timer_start.callback.append(self.startBrowser)
+                       self.timer_start.start(10)
+
+       def getHandlerName(self, v):
+               if v == "mrc":
+                       v = self.rc_mouse
+               elif v == "musb":
+                       v = self.usb_mouse
+               elif v == "krc":
+                       v = self.rc_keyboard
+               elif v == "kusb":
+                       v = self.usb_keyboard
+               for l in self.name_list:
+                       if l[0] == v:
+                               return l[1]
+               return None
 
        def callbackLauncherDataAvail(self, ret_data):
                print ret_data
                if ret_data.startswith("--done--"):
                        self.lock = False
 
        def callbackLauncherDataAvail(self, ret_data):
                print ret_data
                if ret_data.startswith("--done--"):
                        self.lock = False
-                       self.keyCancel()
-               
+                       self.doExit()
+
        def callbackLauncherAppClosed(self, retval = 1):
        def callbackLauncherAppClosed(self, retval = 1):
-               None
+               self.lock = False
+
+def sessionstart(session, **kwargs):
+       enable_rc_mouse(False)
+       change_galpha(set_const=False, set_value=True)
+       excute_cmd("killall -15 arora")
 
 def main(session, **kwargs):
        session.open(BrowserLauncher)
 
 def main(session, **kwargs):
        session.open(BrowserLauncher)
-                                                           
-def Plugins(**kwargs):            
-       return PluginDescriptor(name=_("Web Browser"), description="start web browser", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)
+
+def Plugins(**kwargs):
+       return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, needsRestart = False, fnc=sessionstart),
+               PluginDescriptor(name=_("Web Browser"), description="start web browser", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)]