1 from Plugins.Plugin import PluginDescriptor
3 from Screens.Screen import Screen
4 from Screens.InfoBar import InfoBar
5 from Screens.ChoiceBox import ChoiceBox
6 from Screens.MessageBox import MessageBox
7 from Screens.InfoBarGenerics import InfoBarNotifications
8 from Screens.VirtualKeyBoard import VirtualKeyBoard
9 from Screens.HelpMenu import HelpableScreen
10 from Screens.ChannelSelection import service_types_tv
12 from Components.Language import language
13 from Components.PluginComponent import plugins
14 from Components.Button import Button
15 from Components.Sources.StaticText import StaticText
16 from Components.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
17 from Components.ServiceEventTracker import ServiceEventTracker
18 from Components.MenuList import MenuList
19 from Components.Label import Label, MultiColorLabel
20 from Components.ConfigList import ConfigListScreen
21 from Components.VolumeControl import VolumeControl
22 from Components.Pixmap import Pixmap
23 from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue
25 from enigma import eTimer, eConsoleAppContainer, getDesktop, eServiceReference, iPlayableService, iServiceInformation, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, getPrevAsciiCode, eRCInput, fbClass, eServiceCenter
27 from bookmark import BookmarkManager, BookmarkData, CategoryData
29 import os, struct, threading, stat, select, time, socket, select
31 from __init__ import _
33 strIsEmpty = lambda x: x is None or len(x) == 0
35 HBBTVAPP_PATH = "/usr/local/hbb-browser"
36 COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
46 channel_info_sid = None
47 channel_info_onid = None
48 channel_info_tsid = None
49 channel_info_name = None
50 channel_info_orgid = None
56 packet_hl = struct.calcsize(packet_h)
60 __gval__ = GlobalValues()
62 def setPluginBrowser(browser=None):
64 __gval__.plugin_browser = browser
65 def getPluginBrowser():
67 return __gval__.plugin_browser
69 def getPacketHeaders():
71 return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
73 def setChannelInfo(sid, onid, tsid, name, orgid):
74 if sid is None: sid = 0;
75 if onid is None: onid = 0;
76 if tsid is None: tsid = 0;
77 if name is None: name = "";
78 if orgid is None: orgid = 0;
80 __gval__.channel_info_sid = sid
81 __gval__.channel_info_onid = onid
82 __gval__.channel_info_tsid = tsid
83 __gval__.channel_info_name = name
84 __gval__.channel_info_orgid = orgid
85 print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
86 def getChannelInfos():
88 print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
89 __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
90 return (__gval__.channel_info_sid,
91 __gval__.channel_info_onid,
92 __gval__.channel_info_tsid,
93 __gval__.channel_info_name,
94 __gval__.channel_info_orgid)
98 print "Need Restart(GET) : ", __gval__.need_restart
99 return __gval__.need_restart
100 def setNeedRestart(n):
102 __gval__.need_restart = n
103 print "Need Restart(SET) : ", __gval__.need_restart
105 def getCommandUtil():
107 return __gval__.command_util
108 def getCommandServer():
110 return __gval__.command_server
112 def setBeforeService(s):
114 __gval__.before_service = s
115 def getBeforeService():
117 return __gval__.before_service
119 def _unpack(packed_data):
120 (mg, h, hlen) = getPacketHeaders()
122 if strIsEmpty(packed_data):
124 (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
129 d = packed_data[hlen:hlen+l]
132 def _pack(opcode, params=None, reserved=0):
133 (m, h, hlen) = getPacketHeaders()
134 if strIsEmpty(params):
136 packed_data = struct.pack(h, m, opcode, len(params), reserved)
137 return packed_data + params
143 ,'User-Agent: NSPlayer/7.10.0.3059 '
145 ,'Connection: Close '
150 for m in self.headers:
151 self.sendmsg += m + '\n'
152 self.sendmsg += '\n\n'
154 def request(self, host, port=80, location='/'):
155 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
156 sock.connect((host, port))
157 sock.send(self.sendmsg%(location, host))
159 print self.sendmsg%(location, host)
162 res = sock.recv(1024)
168 def parse(self, data):
169 for d in data.splitlines():
170 if d.startswith('Location: '):
174 def getLocationData(self, url):
175 url_list,host,location = None,None,None
177 url = url[url.find(':')+3:]
178 url_list = url.split('/')
180 location = url[len(url_list[0]):]
181 except Exception, err_msg:
184 html = self.request(host=host, location=location)
185 return self.parse(html)
190 "OP_UNKNOWN" : 0x0000
191 ,"OP_HBBTV_EXIT" : 0x0001
192 ,"OP_HBBTV_OPEN_URL" : 0x0002
193 ,"OP_HBBTV_LOAD_AIT" : 0x0003
194 ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
195 ,"OP_HBBTV_FULLSCREEN" : 0x0005
196 ,"OP_HBBTV_TITLE" : 0x0006
197 ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
198 ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
199 ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
200 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
201 ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
202 ,"OP_VOD_URI" : 0x0201
203 ,"OP_VOD_PLAY" : 0x0202
204 ,"OP_VOD_STOP" : 0x0203
205 ,"OP_VOD_PAUSE" : 0x0204
206 ,"OP_VOD_STATUS" : 0x0205
207 ,"OP_VOD_FORBIDDEN" : 0x0206
208 ,"OP_VOD_STOPED" : 0x0207
209 ,"OP_VOD_SPEED_CTRL" : 0x0208
210 ,"OP_VOD_SEEK_CTRL" : 0x0209
211 ,"OP_BROWSER_OPEN_URL" : 0x0301
212 ,"OP_BROWSER_VKBD_REQ" : 0x0309
213 ,"OP_BROWSER_VKBD_RES" : 0x030A
214 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
215 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
216 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
217 ,"OP_BROWSER_MENU_REQ" : 0x030E
218 ,"OP_BROWSER_MENU_RES" : 0x030F
219 ,"OP_DVBAPP_VOL_UP" : 0x0401
220 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
221 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
222 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
225 0x0000 : "OP_UNKNOWN"
226 ,0x0001 : "OP_HBBTV_EXIT"
227 ,0x0002 : "OP_HBBTV_OPEN_URL"
228 ,0x0003 : "OP_HBBTV_LOAD_AIT"
229 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
230 ,0x0005 : "OP_HBBTV_FULLSCREEN"
231 ,0x0006 : "OP_HBBTV_TITLE"
232 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
233 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
234 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
235 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
236 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
237 ,0x0201 : "OP_VOD_URI"
238 ,0x0202 : "OP_VOD_PLAY"
239 ,0x0203 : "OP_VOD_STOP"
240 ,0x0204 : "OP_VOD_PAUSE"
241 ,0x0205 : "OP_VOD_STATUS"
242 ,0x0206 : "OP_VOD_FORBIDDEN"
243 ,0x0207 : "OP_VOD_STOPED"
244 ,0x0208 : "OP_VOD_SPEED_CTRL"
245 ,0x0209 : "OP_VOD_SEEK_CTRL"
246 ,0x0301 : "OP_BROWSER_OPEN_URL"
247 ,0x0309 : "OP_BROWSER_VKBD_REQ"
248 ,0x030A : "OP_BROWSER_VKBD_RES"
249 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
250 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
251 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
252 ,0x030E : "OP_BROWSER_MENU_REQ"
253 ,0x030F : "OP_BROWSER_MENU_RES"
254 ,0x0401 : "OP_DVBAPP_VOL_UP"
255 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
256 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
257 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
260 def get(self, opstr):
262 return self._opcode_[opstr]
264 return self._opcode_["OP_UNKNOWN"]
266 def what(self, opcode):
268 return self._opstr_[opcode]
270 return self._opstr_["0x0000"]
283 def __init__(self, params):
284 self._protocol = params.protocol
285 self._type = params.type
286 self._addr = params.addr
287 self._buf_size = params.buf_size
288 self._handler = params.handler
289 self._timeout = params.timeout
290 self._destroy = params.destroy
292 self._terminated = False
293 self._server_thread = None
295 self.onHbbTVCloseCB = []
296 self.onSetPageTitleCB = []
299 if self._destroy is not None:
300 self._destroy(self._addr)
303 self._terminated = True
304 if self._server_thread is not None:
305 self._server_thread.join()
306 self._server_thread = None
309 self._socket = socket.socket(self._protocol, self._type)
310 self._socket.settimeout(self._timeout)
311 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
312 self._socket.bind(self._addr)
313 self._socket.listen(True)
315 self._server_thread = threading.Thread(target=self._listen)
316 self._server_thread.start()
319 select_list = [self._socket]
322 conn, addr = self._socket.accept()
323 self._client(conn, addr)
324 except Exception, ErrMsg:
325 print "ServerSocket Error >>", ErrMsg
328 while not self._terminated:
329 readable, writable, errored = select.select(select_list, [], [], self._timeout)
331 if s is self._socket:
334 def _client(self, conn, addr):
337 received_data = conn.recv(self._buf_size)
338 if self._handler is not None and not strIsEmpty(received_data):
339 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
340 self._send(conn, send_data)
341 except Exception, ErrMsg:
344 if self._handler is not None:
345 self._handler.printError(ErrMsg)
346 def _send(self, conn, data) :
351 def doListenUnixTCP(self, name, handler):
353 if os.path.exists(name):
355 print "Removed ", name
358 params = SocketParams()
359 params.protocol = socket.AF_UNIX
360 params.type = socket.SOCK_STREAM
362 params.handler = handler
363 params.destroy = destroy
365 streamServer = StreamServer(params)
369 def doListenInetTCP(self, ip, port, handler):
370 print "Not implemented yet!!"
371 def doListenUnixDGRAM(self, name, handler):
372 print "Not implemented yet!!"
373 def doListenInetDGRAM(self, ip, port, handler):
374 print "Not implemented yet!!"
377 def doUnpack(self, data):
380 def doPack(self, opcode, params, reserved=0):
381 return _pack(opcode, params, reserved)
383 def doHandle(self, data, onCloseCB):
384 opcode, params = 0x0, 'Invalid Request!!'
385 return _pack(opcode, params)
387 def printError(self, reason):
390 class BrowserCommandUtil(OpCodeSet):
393 OpCodeSet.__init__(self)
395 def isConnected(self):
400 def doConnect(self, filename):
401 if not os.path.exists(filename):
402 print "File not exists :", filename
405 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
407 print "Fail to open file :", filename
409 except Exception, ErrMsg:
415 def doDisconnect(self):
421 def doSend(self, command, params=None, reserved=0):
423 print "No found pipe!!"
427 data = _pack(self.get(command), params, reserved)
430 os.write(self._fd, data)
431 print "Send OK!! :", command
435 def sendCommand(self, command, params=None, reserved=0):
436 if not self.isConnected():
438 self.doConnect(COMMAND_PATH)
439 result = self.doSend(command, params, reserved)
443 class HandlerHbbTV(Handler):
445 def __init__(self, session):
446 self._session = session
447 self.opcode = OpCodeSet()
449 0x0001 : self._cb_handleCloseHbbTVBrowser
450 ,0x0006 : self._cb_handleSetPageTitle
451 ,0x0009 : self._cb_handleHbbTVRetryOpen
452 ,0x000A : self._cb_handleHbbTVChangeChannel
453 ,0x0101 : self._cb_handleGetChannelInfoForUrl
454 ,0x0102 : self._cb_handleGetChannelInfoForAIT
455 ,0x0103 : self._cb_handleGetChannelInfoList
456 ,0x0201 : self._cb_handleVODPlayerURI
457 ,0x0202 : self._cb_handleVODPlayerPlay
458 ,0x0203 : self._cb_handleVODPlayerStop
459 ,0x0204 : self._cb_handleVODPlayerPlayPause
460 ,0x0401 : self._cb_handleDVBAppVolUp
461 ,0x0402 : self._cb_handleDVBAppVolDown
462 ,0x0208 : self._cb_handleVODSpeedCtrl
463 ,0x0209 : self._cb_handleVODSeekCtrl
464 ,0x0501 : self._cb_handleSystemOutOfMemory
465 ,0x0502 : self._cb_handleSystemNotufyMyPID
466 ,0x0309 : self._cb_handleShowVirtualKeyboard
467 ,0x030B : self._cb_handlePasteVirtualKeyboard
468 ,0x030E : self._cb_handleBrowserMenuReq
470 self._on_close_cb = None
471 self._on_set_title_cb = None
475 self._retry_open_url = None
476 self._timer_retry_open = eTimer()
477 self._timer_paste_vkbd = eTimer()
478 self._curren_title = None
480 def _handle_dump(self, handle, opcode, data=None):
484 print " - opcode : ", self.opcode.what(opcode)
486 print " - data : ", data
488 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
489 opcode, params, reserved = None, None, 0
490 self._on_close_cb = onCloseCB
491 self._on_set_title_cb = onSetPageTitleCB
493 datas = self.doUnpack(data)
494 except Exception, ErrMsg:
495 print "Unpacking packet ERR :", ErrMsg
496 params = 'fail to unpack packet!!'
497 opcode = self.opcode.get("OP_UNKNOWN")
498 return self.doPack(opcode, params)
502 self.opcode.what(opcode)
505 #print self.handle_map[opcode]
506 (reserved, params) = self.handle_map[opcode](opcode, params)
507 except Exception, ErrMsg:
508 print "Handling packet ERR :", ErrMsg
509 params = 'fail to handle packet!!'
510 opcode = self.opcode.get("OP_UNKNOWN")
511 return self.doPack(opcode, params)
512 self._on_close_cb = None
513 self._on_set_title_cb = None
514 return self.doPack(opcode, params, reserved)
516 def _cb_handleHbbTVChangeChannel(self, opcode, data):
517 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
519 if _g_helper is None:
521 dataItems = data.split(":")
524 if not _g_helper.doChangeChannel(sid, tsid):
528 def _cb_handleBrowserMenuReq(self, opcode, data):
529 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
530 fbClass.getInstance().unlock()
531 eRCInput.getInstance().unlock()
532 browser = getPluginBrowser()
533 if browser is not None:
534 browser.setCurrentPageUrl(data, self._curren_title)
537 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
538 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
539 def _cb_PasteRefocusVirtualKeyboard():
540 self._timer_paste_vkbd.stop()
541 command_util = getCommandUtil()
542 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
544 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
546 def _cb_PasteKeyVirtualKeyboard():
547 self._timer_paste_vkbd.stop()
548 command_util = getCommandUtil()
549 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
551 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
553 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
554 self._timer_paste_vkbd.start(100)
555 def _cb_PasteMouseVirtualKeyboard():
556 self._timer_paste_vkbd.stop()
557 command_util = getCommandUtil()
558 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
560 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
562 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
564 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
565 #self._timer_paste_vkbd.start(1000)
566 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
567 self._timer_paste_vkbd.start(50)
570 def _cb_virtualKeyboardClosed(self, data=None):
571 fbClass.getInstance().lock()
572 eRCInput.getInstance().lock()
573 command_util = getCommandUtil()
574 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
575 def _cb_handleShowVirtualKeyboard(self, opcode, data):
576 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
577 fbClass.getInstance().unlock()
578 eRCInput.getInstance().unlock()
579 if data == 0 or strIsEmpty(data):
581 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
584 def _cb_handleVODSeekCtrl(self, opcode, data):
585 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
586 headLen = struct.calcsize('!I')
587 unpackedData = struct.unpack('!I', data[:headLen])
588 seekTime = unpackedData[0]
589 service = self._session.nav.getCurrentService()
590 seekable = service.seek()
591 if seekable is None or not seekable.isCurrentlySeekable():
592 raise Exception("This stream is not support manual seek.")
594 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
597 def _cb_handleHbbTVRetryOpen(self, opcode, data):
598 def _cb_HbbTVRetryOpenURL():
599 self._timer_retry_open.stop()
600 if self._retry_open_url is not None:
601 command_util = getCommandUtil()
602 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
603 self._retry_open_url = None
605 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
607 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
608 headLen = struct.calcsize('!I')
609 unpackedData = struct.unpack('!I', data[:headLen])
610 delayTime = unpackedData[0]
611 restartUrl = data[headLen:]
613 self._retry_open_url = restartUrl.strip()
614 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
615 self._timer_retry_open.start(delayTime*1000)
618 def _cb_handleSystemNotufyMyPID(self, opcode, data):
619 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
622 def _cb_handleSystemOutOfMemory(self, opcode, data):
623 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
627 def _cb_handleVODSpeedCtrl(self, opcode, data):
628 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
629 headLen = struct.calcsize('!I')
630 unpackedData = struct.unpack('!I', data[:headLen])
631 playSpeed = unpackedData[0]
632 service = self._session.nav.getCurrentService()
633 pauseable = service.pause()
636 if pauseable.setFastForward(playSpeed) == -1:
637 pauseable.setFastForward(1)
638 raise Exception("This stream is not support trick play.")
641 def _cb_handleDVBAppVolUp(self, opcode, data):
642 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
643 vcm = VolumeControl.instance
647 def _cb_handleDVBAppVolDown(self, opcode, data):
648 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
649 vcm = VolumeControl.instance
653 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
654 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
655 (sid, onid, tsid, name, orgid) = getChannelInfos()
657 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
659 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
660 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
661 (sid, onid, tsid, name, orgid) = getChannelInfos()
663 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
665 def _cb_handleGetChannelInfoList(self, opcode, data):
666 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
667 (sid, onid, tsid, name, orgid) = getChannelInfos()
669 channel_list_size = 1
670 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
672 def _cb_handleSetPageTitle(self, opcode, data):
673 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
674 if data.startswith('file://') or data.startswith('http://'):
676 if self._on_set_title_cb is not None:
677 for x in self._on_set_title_cb:
680 self._curren_title = data
681 except Exception, ErrMsg:
682 if x in self._on_set_title_cb:
683 self._on_set_title_cb.remove(x)
686 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
687 self._timer_retry_open.stop()
689 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
691 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
693 if self._on_close_cb:
694 for x in self._on_close_cb:
697 except Exception, ErrMsg:
698 if x in self._on_close_cb:
699 self._on_close_cb.remove(x)
701 command_util = getCommandUtil()
702 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
704 before_service = getBeforeService()
705 if before_service is not None:
706 self._session.nav.playService(before_service)
710 def _cb_handleVODPlayerURI(self, opcode, data):
712 hl = struct.calcsize('!II')
713 datas = struct.unpack('!II', data[:hl])
715 vodUri = data[hl:hl+uriLength]
716 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
717 self._vod_uri = vodUri
720 def doStop(self, restoreBeforeService=True, needStop=True):
722 self._session.nav.stopService()
723 if self._vod_service is not None and restoreBeforeService:
724 before_service = getBeforeService()
725 self._session.nav.playService(before_service)
727 self._vod_service = None
732 def doRetryOpen(self, url):
736 self._vod_service = None
738 print "Try to open vod [%d] : %s" % (ii, url)
739 self._vod_service = eServiceReference(4097, 0, url)
740 self._session.nav.playService(self._vod_service)
741 if self._vod_service is not None:
743 except Exception, ErrMsg:
744 print "OpenVOD ERR :", ErrMsg
748 def _cb_handleVODPlayerPlay(self, opcode, data):
749 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
750 self.doStop(restoreBeforeService=False)
751 if self.doRetryOpen(url=self._vod_uri) == False:
755 def _cb_handleVODPlayerStop(self, opcode, data):
756 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
760 def _cb_handleVODPlayerPlayPause(self, opcode, data):
761 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
762 service = self._session.nav.getCurrentService()
765 servicePause = service.pause()
767 servicePause.unpause()
768 elif pauseFlag == 'P':
770 except Exception, ErrMsg:
771 print "onPause ERR :", ErrMsg
774 from libshm import SimpleSharedMemory
776 class HbbTVWindow(Screen, InfoBarNotifications):
778 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
781 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
782 self._session = session
783 fbClass.getInstance().lock()
784 eRCInput.getInstance().lock()
786 Screen.__init__(self, session)
787 InfoBarNotifications.__init__(self)
788 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
789 iPlayableService.evUser+20: self._serviceForbiden,
790 iPlayableService.evStart: self._serviceStarted,
791 iPlayableService.evEOF: self._serviceEOF,
795 self._use_ait = useAIT
796 self._profile = profile
797 self._cb_closed_func = cbf
798 self.onLayoutFinish.append(self._layoutFinished)
800 command_server = getCommandServer()
801 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
802 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
804 if self._cb_close_window not in command_server.onHbbTVCloseCB:
805 command_server.onHbbTVCloseCB.append(self._cb_close_window)
807 self._closeTimer = eTimer()
808 self._closeTimer.callback.append(self._do_close)
810 self._currentServicePositionTimer = eTimer()
811 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
818 def getVodPlayTime(self):
820 service = self._session.nav.getCurrentService()
821 seek = service and service.seek()
823 p = seek.getPlayPosition()
824 #return (p[1]/90000, l[1]/90000)
829 def _cb_currentServicePosition(self):
830 def getTimeString(t):
831 t = time.localtime(t/90000)
832 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
833 position,length = 0,0
835 (position,length) = self.getVodPlayTime()
836 self._vod_length = length
837 if position == -1 and length == -1:
838 raise Exception("Can't get play status")
839 #print getTimeString(position), "/", getTimeString(length)
840 self._ssm.setStatus(position, length, 1)
841 except Exception, ErrMsg:
845 def _serviceStarted(self):
847 self._ssm.setStatus(0, 0, 0)
848 self._currentServicePositionTimer.start(1000)
849 except Exception, ErrMsg:
852 def _serviceEOF(self):
853 self._currentServicePositionTimer.stop()
855 def _layoutFinished(self):
856 self.setTitle(_('HbbTV Plugin'))
857 command_util = getCommandUtil()
858 profile = self._profile
859 (sid, onid, tsid, name, orgid) = getChannelInfos()
860 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
862 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
864 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
866 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
868 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
870 def _cb_close_window(self):
871 self._closeTimer.start(1000)
874 self._closeTimer.stop()
875 command_server = getCommandServer()
877 if self._cb_set_page_title in command_server.onSetPageTitleCB:
878 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
879 except Exception, ErrMsg: pass
881 if self._cb_close_window in command_server.onHbbTVCloseCB:
882 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
883 except Exception, ErrMsg: pass
885 if self._cb_closed_func is not None:
886 self._cb_closed_func()
888 fbClass.getInstance().unlock()
889 eRCInput.getInstance().unlock()
892 def _serviceForbiden(self):
894 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
895 print "Received URI :\n", real_url
897 if real_url is not None:
898 __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
900 def _cb_set_page_title(self, title=None):
901 print "page title :",title
906 class HbbTVHelper(Screen):
907 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
908 def __init__(self, session):
910 __gval__.hbbtv_handelr = HandlerHbbTV(session)
911 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
916 self._restart_opera()
918 Screen.__init__(self, session)
919 self._session = session
920 self._timer_infobar = eTimer()
921 self._timer_infobar.callback.append(self._cb_registrate_infobar)
922 self._timer_infobar.start(1000)
924 self._excuted_browser = False
927 __gval__.command_util = BrowserCommandUtil()
931 _g_ssm_ = SimpleSharedMemory()
934 def _cb_registrate_infobar(self):
936 self._timer_infobar.stop()
937 if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
938 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
939 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
940 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
942 def _cb_ready_for_ait(self, orgId=0):
944 if not self._excuted_browser:
945 command_util = getCommandUtil()
946 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
948 setChannelInfo(None, None, None, None, None)
950 service = self._session.nav.getCurrentService()
951 info = service and service.info()
953 sid = info.getInfo(iServiceInformation.sSID)
954 onid = info.getInfo(iServiceInformation.sONID)
955 tsid = info.getInfo(iServiceInformation.sTSID)
956 name = info.getName()
961 for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
965 setChannelInfo(sid, onid, tsid, name, orgid)
967 def _cb_hbbtv_activated(self, title=None, url=None):
968 if not self._is_browser_running():
969 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
970 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
972 service = self._session.nav.getCurrentlyPlayingServiceReference()
973 setBeforeService(service)
974 self._start_hbbtv_application(title, url)
976 def _start_hbbtv_application(self, title, url):
978 tmp_url = self.getStartHbbTVUrl()
982 print "can't get url of hbbtv!!"
984 print "success to get url of hbbtv!! >>", url
985 if self._excuted_browser:
986 print "already excuted opera browser!!"
990 self._restart_opera()
992 setNeedRestart(False)
997 if tmp_url == url and control_code == 1:
999 self._excuted_browser = True
1000 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1002 def _cb_closed_browser(self):
1003 self._excuted_browser = False
1005 def _start_opera(self):
1006 if not self._is_browser_running():
1007 global HBBTVAPP_PATH
1008 start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1009 os.system(start_command)
1011 def _stop_opera(self):
1012 global HBBTVAPP_PATH
1013 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1016 def _restart_opera(self):
1017 global HBBTVAPP_PATH
1018 try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1021 def getStartHbbTVUrl(self):
1022 url, self._urls, self._profile = None, None, 0
1023 service = self._session.nav.getCurrentService()
1024 info = service and service.info()
1025 if not info: return None
1026 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1027 for u in self._urls:
1028 if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1030 self._profile = u[5]
1032 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1035 def showApplicationSelectionBox(self):
1038 if self.getStartHbbTVUrl():
1039 for x in self._urls:
1040 applications.append((x[1], x))
1041 else: applications.append((_("No detected HbbTV applications."), None))
1042 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1044 def _application_selected(self, selected):
1046 if selected[1] is None: return
1047 self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1048 except Exception, ErrMsg: print ErrMsg
1050 def showBrowserConfigBox(self):
1051 start_stop_mode = []
1052 if self._is_browser_running():
1053 start_stop_mode.append((_('Stop'),'Stop'))
1054 else: start_stop_mode.append((_('Start'),'Start'))
1055 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1057 def _browser_config_selected(self, selected):
1058 if selected is None:
1063 if not self._is_browser_running():
1065 elif mode == 'Stop':
1067 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1069 def _is_browser_running(self):
1071 global HBBTVAPP_PATH
1072 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1073 return ret.strip() != "0"
1074 except Exception, ErrMsg:
1075 print "Check Browser Running ERR :", ErrMsg
1078 def doChangeChannel(self, _sid, _tsid):
1079 root = eServiceReference(service_types_tv)
1082 serviceList = eServiceCenter.getInstance().list(root)
1083 if serviceList is None:
1086 service = serviceList.getNext()
1087 if service is None or not service.valid():
1090 #1:0:19:2840:3FB:1:C00000:0:0:0:
1091 serviceRef = service.toString()
1092 if strIsEmpty(serviceRef):
1094 serviceRefItems = serviceRef.split(":")
1095 if len(serviceRefItems) < 5:
1098 sid = serviceRefItems[3]
1099 tsid = serviceRefItems[4]
1100 if sid == _sid and tsid == _tsid:
1101 self._session.nav.playService(eServiceReference(serviceRef))
1102 service = self._session.nav.getCurrentlyPlayingServiceReference()
1103 setBeforeService(service)
1107 class OperaBrowserSetting:
1109 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1114 f = open(self._settingFileName)
1115 for line in f.readlines():
1116 if line.startswith('start='):
1117 tmp = line[6:len(line)-1].split()
1118 self._start = tmp[0]
1120 self._type = int(tmp[1])
1121 else: self._type = 0
1125 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1126 f = open(self._settingFileName, 'w')
1127 f.writelines(tmpstr)
1129 def setData(self, start, types=0):
1135 'start':self._start,
1139 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1141 <screen position="center,center" size="600,350" title="Preference">
1142 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1143 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1145 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1146 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1148 <widget source="key_red" render="Label" position="310,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1149 <widget source="key_green" render="Label" position="150,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1152 def __init__(self, session, currentUrl):
1153 self.session = session
1154 Screen.__init__(self, session)
1157 ConfigListScreen.__init__(self, self.menulist)
1159 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1160 "red" : self.keyRed,
1161 "green" : self.keyGreen,
1163 "cancel" : self.keyRed
1165 self["key_red"] = StaticText(_("Cancel"))
1166 self["key_green"] = StaticText(_("Save"))
1167 self["url"] = Label()
1169 self._currentPageUrl = currentUrl
1170 if self._currentPageUrl is None:
1171 self._currentPageUrl = ''
1172 self._startPageUrl = None
1174 self.makeMenuEntry()
1175 self.onLayoutFinish.append(self.layoutFinished)
1177 def layoutFinished(self):
1178 self.setTitle(_('Preference'))
1180 d = OperaBrowserSetting().getData()
1181 self._startPageUrl = d['start']
1183 except: self._startPageUrl = 'http://vuplus.com'
1184 self.updateStartPageUrl()
1186 def updateStartPageUrl(self):
1187 if self.menuItemStartpage.value == "startpage":
1188 self["url"].setText(self._startPageUrl)
1189 elif self.menuItemStartpage.value == "current":
1190 self["url"].setText(self._currentPageUrl)
1191 elif self.menuItemStartpage.value == "direct":
1192 self["url"].setText('')
1195 url = self["url"].getText()
1197 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1200 if url.find('/usr/local/manual') > 0:
1202 OperaBrowserSetting().setData(url, mode)
1209 def _cb_directInputUrl(data):
1210 if strIsEmpty(data):
1212 self["url"].setText(data)
1213 if self.menuItemStartpage.value == "direct":
1214 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1217 ConfigListScreen.keyLeft(self)
1218 self.updateStartPageUrl()
1221 ConfigListScreen.keyRight(self)
1222 self.updateStartPageUrl()
1224 def makeMenuEntry(self):
1226 l.append(("startpage", _("Start Page")))
1227 if not strIsEmpty(self._currentPageUrl):
1228 l.append(("current", _("Current Page")))
1229 l.append(("direct", _("Direct Input")))
1230 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1231 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1232 self.resetMenuList()
1234 def resetMenuList(self):
1236 self.menulist.append(self.menuEntryStartpage)
1238 self["config"].list = self.menulist
1239 self["config"].l.setList(self.menulist)
1241 class BookmarkEditWindow(ConfigListScreen, Screen):
1242 CATEGORY,BOOKMARK = 0,1
1244 <screen position="center,center" size="600,140" title="Bookmark Edit">
1245 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1247 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1248 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1250 <widget source="key_red" render="Label" position="310,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1251 <widget source="key_green" render="Label" position="150,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1253 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1257 def __init__(self, session, _mode, _type, _data, _bm):
1261 self.mSession = session
1262 self.mBookmarkManager = _bm
1264 if _data is not None:
1267 Screen.__init__(self, session)
1270 ConfigListScreen.__init__(self, self.menulist)
1272 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1273 "ok" : self.keyGreen,
1274 "green" : self.keyGreen,
1275 "red" : self.keyRed,
1276 "cancel" : self.keyRed,
1279 self["VKeyIcon"] = Pixmap()
1280 self["key_red"] = StaticText(_("Cancel"))
1281 self["key_green"] = StaticText(_("Save"))
1283 self.menuItemTitle = None
1284 self.menuItemUrl = None
1285 self.menuItemName = None
1287 self.menuEntryName = None
1288 self.menuEntryTitle = None
1289 self.menuEntryUrl = None
1291 self.makeConfigList()
1292 self.onLayoutFinish.append(self.layoutFinished)
1294 def layoutFinished(self):
1295 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1297 def selectedItem(self):
1298 currentPosition = self["config"].getCurrent()
1299 if self.mType == BookmarkEditWindow.CATEGORY:
1300 return (_("Name"), self.menuItemName)
1302 if currentPosition == self.menuEntryTitle:
1303 return (_("Title"), self.menuItemTitle)
1304 elif currentPosition == self.menuEntryUrl:
1305 return (_("Url"), self.menuItemUrl)
1308 def showMessageBox(self, text):
1309 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1310 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1313 def showVKeyWindow(self, data=None):
1316 selected = self.selectedItem()
1317 if selected is not None:
1318 itemValue = selected[1].value
1319 if strIsEmpty(itemValue):
1321 itemTitle = selected[0]
1323 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1325 def cbVKeyWindow(self, data=None):
1326 if data is not None:
1327 selected = self.selectedItem()
1328 if selected is not None:
1329 selected[1].setValue(data)
1332 if self.mType == BookmarkEditWindow.CATEGORY:
1333 if self.mMode == _('Add'):
1334 categoryName = self.menuItemName.value
1335 if strIsEmpty(categoryName):
1336 return self.showMessageBox(_("Category Name"))
1337 self.mBookmarkManager.addCategory(categoryName)
1339 if strIsEmpty(self.menuItemName.value):
1340 return self.showMessageBox(_("Category Name"))
1341 self.mData.mName = self.menuItemName.value
1342 self.mBookmarkManager.updateCategory(self.mData)
1344 if self.mMode == _('Add'):
1345 bookmarkTitle = self.menuItemTitle.value
1346 bookmarkUrl = self.menuItemUrl.value
1347 if strIsEmpty(bookmarkTitle):
1348 self["config"].setCurrentIndex(0)
1349 return self.showMessageBox(_("Bookmark Title"))
1350 if strIsEmpty(bookmarkUrl):
1351 self["config"].setCurrentIndex(1)
1352 return self.showMessageBox(_("Bookmark URL"))
1353 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1355 if strIsEmpty(self.menuItemTitle.value):
1356 self["config"].setCurrentIndex(0)
1357 return self.showMessageBox(_("Bookmark Title"))
1358 if strIsEmpty(self.menuItemUrl.value):
1359 self["config"].setCurrentIndex(1)
1360 return self.showMessageBox(_("Bookmark URL"))
1361 self.mData.mTitle = self.menuItemTitle.value
1362 self.mData.mUrl = self.menuItemUrl.value
1363 self.mBookmarkManager.updateBookmark(self.mData)
1367 if not self.saveData():
1373 ConfigListScreen.keyLeft(self)
1375 ConfigListScreen.keyRight(self)
1376 def makeConfigList(self):
1379 if self.mType == BookmarkEditWindow.CATEGORY:
1380 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1382 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1384 self.menulist.append(self.menuEntryName)
1386 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1387 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1389 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1390 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1392 self.menulist.append(self.menuEntryTitle)
1393 self.menulist.append(self.menuEntryUrl)
1395 self["config"].list = self.menulist
1396 self["config"].l.setList(self.menulist)
1398 class OperaBrowserBookmarkWindow(Screen):
1400 <screen name="HbbTVBrowserBookmarkWindow" position="center,center" size="600,400" title="Bookmark" >
1401 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1403 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1404 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1406 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1407 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1408 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1409 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1411 <widget source="key_red" render="Label" position="5,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1412 <widget source="key_green" render="Label" position="155,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1413 <widget source="key_yellow" render="Label" position="305,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
1414 <widget source="key_blue" render="Label" position="450,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
1418 def __init__(self, _session, _url=None, _title=None):
1420 self.mTitle = _title
1421 self.mBookmarkManager = BookmarkManager.getInstance()
1422 self.mSession = _session
1423 Screen.__init__(self, _session)
1424 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1426 "cancel": self.keyCancel,
1427 "red" : self.keyRed,
1428 "green" : self.keyGreen,
1429 "yellow": self.keyYellow,
1430 "blue" : self.keyBlue,
1431 "0" : self.keyNumber,
1434 self["key_red"] = StaticText(_("Exit"))
1435 self["key_green"] = StaticText(_("Add"))
1436 self["key_yellow"] = StaticText(_("Edit"))
1437 self["key_blue"] = StaticText(_("Delete"))
1438 self["key_0"] = StaticText(_("Set as Startpage"))
1440 self.mBookmarkList = self.setBookmarkList()
1441 self["bookmarklist"] = MenuList(self.mBookmarkList)
1443 self.onLayoutFinish.append(self.layoutFinished)
1445 def layoutFinished(self):
1446 self.setTitle(_('Bookmark'))
1448 def setBookmarkList(self):
1450 #self.mBookmarkManager.dump()
1451 cd = self.mBookmarkManager.getBookmarkRoot()
1452 for ck in cd.iterkeys():
1453 l.append(('# ' + cd[ck].mName, cd[ck]))
1454 bd = cd[ck].mBookmarks
1455 for bk in bd.iterkeys():
1456 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1458 def updateBookmarkList(self):
1459 self.mBookmarkList = self.setBookmarkList()
1460 self["bookmarklist"].setList(self.mBookmarkList)
1461 def cbEditWindow(self, ret=False):
1464 self.updateBookmarkList()
1465 def getParentCategory(self):
1466 idx = self["bookmarklist"].getSelectedIndex()
1469 data = self.mBookmarkList[idx][0].strip()
1471 return self.mBookmarkList[idx][1]
1475 def isCategoryItem(self):
1477 head = self["bookmarklist"].getCurrent()[0].strip()
1482 def keyNumber(self):
1483 data = self["bookmarklist"].getCurrent()[1]
1484 if strIsEmpty(data.mUrl):
1485 msg = _("Invalid URL. Please check again!!")
1486 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1488 def cbSetStartpage(ret=None):
1489 if ret is None: return
1491 data = self["bookmarklist"].getCurrent()[1]
1492 OperaBrowserSetting().setData(data.mUrl, data.mType)
1493 msg = _("Do you want to set selected url to the Startpage?")
1494 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1501 parent = self.getParentCategory()
1504 if strIsEmpty(self.mTitle):
1506 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1508 msg = _("Current page is already exist.")
1509 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1510 self.cbEditWindow(True)
1512 parent = self.getParentCategory()
1515 b = BookmarkData(0, '', '', parent.mId, 0)
1516 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1518 c = CategoryData(0, '')
1519 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1520 if strIsEmpty(self.mUrl):
1521 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1522 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1523 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1524 def keyYellow(self):
1525 data = self["bookmarklist"].getCurrent()[1]
1526 if self.isCategoryItem():
1527 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1528 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1530 def cbBlue(ret=None):
1532 data = self["bookmarklist"].getCurrent()[1]
1533 if self.isCategoryItem():
1534 self.mBookmarkManager.deleteCategory(data.mId)
1535 else: self.mBookmarkManager.deleteBookmark(data.mId)
1536 self.updateBookmarkList()
1537 if self.isCategoryItem():
1538 msg = _("Do you want to delete the category and the bookmarks?")
1539 else: msg = _("Do you want to delete the bookmark?")
1540 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1542 if self.isCategoryItem(): return
1544 data = self["bookmarklist"].getCurrent()[1]
1545 url = data.mUrl.strip()
1547 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1551 lang = language.getLanguage()
1552 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1553 url = '/usr/local/manual/ru_RU/main.html'
1554 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1555 url = '/usr/local/manual/de_DE/main.html'
1556 self.close((url, mode))
1559 def keyCancel(self):
1562 class BrowserHelpWindow(Screen, HelpableScreen):
1563 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1565 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1566 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1567 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1568 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1569 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1571 <widget source="key_red" render="Label" position="5,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1572 <widget source="key_green" render="Label" position="155,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1573 <widget source="key_yellow" render="Label" position="305,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
1574 <widget source="key_blue" render="Label" position="450,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
1577 def __init__(self, session):
1578 Screen.__init__(self, session)
1579 HelpableScreen.__init__(self)
1581 self["key_red"] = StaticText(_("Exit"))
1582 self["key_green"] = StaticText(_("Global"))
1583 self["key_yellow"] = StaticText(_("Mouse"))
1584 self["key_blue"] = StaticText(_("Keyboard"))
1586 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1588 "cancel": self.keyRed,
1589 "red" : self.keyRed,
1590 "green" : self.keyGreen,
1591 "yellow": self.keyYellow,
1592 "blue" : self.keyBlue,
1595 self.showHelpTimer = eTimer()
1596 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1597 self.showHelpTimer.start(500)
1599 self.onLayoutFinish.append(self.layoutFinished)
1601 def layoutFinished(self):
1602 self.setTitle(_('Browser Help'))
1604 def cbShowHelpTimerClosed(self):
1605 self.showHelpTimer.stop()
1606 self.setHelpModeActions(self.MODE_GLOBAL)
1608 def setHelpModeActions(self, _mode=0):
1610 if _mode == self.MODE_GLOBAL:
1611 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1612 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1614 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1615 "menu" : (self.keyPass, _("Show the Menu window.")),
1617 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1618 "green" : (self.keyPass, _("Enter Key")),
1619 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1620 "blue" : (self.keyPass, _("Backspace Key")),
1622 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1623 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1626 elif _mode == self.MODE_MOUSE:
1627 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1628 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1629 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1630 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1631 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1633 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1634 "ok" : (self.keyPass, _("Left Mouse Button")),
1636 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1637 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1638 "nextService" : (self.keyPass, _("Left Key")),
1639 "prevService" : (self.keyPass, _("Right Key")),
1641 elif _mode == self.MODE_KEYBOARD:
1642 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1643 "up" : (self.keyPass, _("Up Key")),
1644 "down" : (self.keyPass, _("Down Key")),
1645 "left" : (self.keyPass, _("Left Key")),
1646 "right" : (self.keyPass, _("Right Key")),
1648 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1649 "ok" : (self.keyPass, _("Enter Key")),
1651 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1652 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1653 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1654 "nextService" : (self.keyPass, _("Go to previous page.")),
1655 "prevService" : (self.keyPass, _("Go to next page.")),
1667 self.setHelpModeActions(self.MODE_GLOBAL)
1668 def keyYellow(self):
1669 self.setHelpModeActions(self.MODE_MOUSE)
1671 self.setHelpModeActions(self.MODE_KEYBOARD)
1673 class OperaBrowser(Screen):
1674 MENUBAR_ITEM_WIDTH = 150
1675 MENUBAR_ITEM_HEIGHT = 30
1676 SUBMENULIST_WIDTH = 200
1677 SUBMENULIST_HEIGHT = 25
1678 SUBMENULIST_NEXT = 2
1681 <screen name="Opera Browser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1682 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1683 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1684 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1685 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1686 <widget name="menulist" position="50,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1687 <widget name="submenulist" position="%d,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1688 <widget name="bottomArea" position="0,640" size="1280,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1690 """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)# modify menu
1692 MENUITEMS_LIST =[[(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1693 [(_('Bookmark'), None), (_('Preference'), None)],
1694 [(_('About'), None), (_('Help'), None)]]
1695 def __init__(self, session, url=None):
1696 Screen.__init__(self, session)
1697 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1698 "cancel" : self.keyCancel
1700 ,"left" : self.keyLeft
1701 ,"right" : self.keyRight
1703 ,"down" : self.keyDown
1704 ,"menu" : self.keyMenu
1707 self._terminatedBrowser = True
1708 self._enableKeyEvent = True
1709 self._currentPageUrl = None
1710 self._currentPageTitle = None
1711 self.menubarCurrentIndex = 0
1712 self.lvMenuItems = []
1713 self.lvSubMenuItems = []
1715 self["topArea"] = Label()
1716 self["bottomArea"] = Label()
1718 self["menuitemFile"] = MultiColorLabel()# modify menu
1719 self["menuitemTool"] = MultiColorLabel()
1720 self["menuitemHelp"] = MultiColorLabel()
1722 self["menulist"] = MenuList(self.setListOnView())
1723 self["submenulist"] = MenuList(self.setSubListOnView())
1725 self.toggleMainScreenFlag = True
1726 self.toggleListViewFlag = False
1727 self.toggleSubListViewFlag = False
1728 self.currentListView = self["menulist"]
1730 self.onLayoutFinish.append(self.layoutFinished)
1732 self._onCloseTimer = eTimer()
1733 self._onCloseTimer.callback.append(self._cb_onClose)
1737 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1738 rcmouse_path = "/proc/stb/fp/mouse"
1739 if os.path.exists(rcmouse_path):
1740 os.system("echo %d > %s" % (mode, rcmouse_path))
1742 def layoutFinished(self):
1743 self["menuitemFile"].setText(_("File"))# modify menu
1744 self["menuitemTool"].setText(_("Tools"))
1745 self["menuitemHelp"].setText(_("Help"))
1747 self["menulist"].hide()
1748 self["submenulist"].hide()
1750 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1751 self.setTitle(_("BrowserMain"))
1752 self.selectMenuitem()
1754 if self.paramUrl is not None:
1756 self.cbUrlText(self.paramUrl, 1)
1758 def selectMenuitem(self):
1759 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1760 self["menuitemFile"].setForegroundColorNum(0)
1761 self["menuitemTool"].setForegroundColorNum(0)
1762 self["menuitemHelp"].setForegroundColorNum(0)
1763 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1765 def popupCloseAll(self):
1771 def setListOnView(self):
1772 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1773 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1774 l = [(_('Return'), None)]
1775 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1776 return self.lvMenuItems
1778 def setSubListOnView(self):
1779 self.lvSubMenuItems = []
1780 xl = self["menulist"].getCurrent()[1]
1781 if xl is None: return []
1783 self.lvSubMenuItems.append((x,None))
1784 return self.lvSubMenuItems
1786 def toggleMainScreen(self):
1787 if not self.toggleMainScreenFlag:
1790 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1792 def toggleListView(self):
1793 if not self.toggleListViewFlag:
1794 self["menulist"].show()
1795 else: self["menulist"].hide()
1796 self.toggleListViewFlag = not self.toggleListViewFlag
1798 def toggleSubListView(self):
1799 if not self.toggleSubListViewFlag:
1800 self["submenulist"].show()
1801 else: self["submenulist"].hide()
1802 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1804 def setCurrentListView(self, listViewIdx):
1805 if listViewIdx == 0:
1806 self.currentListView = None
1807 elif listViewIdx == 1:
1808 self.currentListView = self["menulist"]
1809 elif listViewIdx == 2:
1810 self.currentListView = self["submenulist"]
1812 def _cb_onClose(self):
1813 self._onCloseTimer.stop()
1814 command_server = getCommandServer()
1816 if self._on_close_window in command_server.onHbbTVCloseCB:
1817 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1818 except Exception, ErrMsg: pass
1820 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1821 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1822 except Exception, ErrMsg: pass
1823 self._on_setPageTitle(_('Opera Browser'))
1824 self.enableRCMouse(False)
1825 self.toggleMainScreen()
1826 fbClass.getInstance().unlock()
1827 eRCInput.getInstance().unlock()
1828 self._terminatedBrowser = True
1829 self._enableKeyEvent = True
1830 #if not self.toggleListViewFlag:
1832 self._currentPageUrl = ''
1833 if self.paramUrl is not None:
1839 def _on_setPageTitle(self, title=None):
1840 print "Title :",title
1843 self.setTitle(title)
1845 def cbUrlText(self, data=None, mode=0):
1846 print "Inputed Url :", data, mode
1847 if strIsEmpty(data):
1850 command_server = getCommandServer()
1851 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1852 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1853 if self._on_close_window not in command_server.onHbbTVCloseCB:
1854 command_server.onHbbTVCloseCB.append(self._on_close_window)
1855 self.toggleMainScreen()
1856 self.enableRCMouse(True)
1857 fbClass.getInstance().lock()
1858 eRCInput.getInstance().lock()
1859 command_util = getCommandUtil()
1860 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1861 self._terminatedBrowser = False
1862 self._enableKeyEvent = False
1864 def _on_close_window(self):
1865 self._onCloseTimer.start(1000)
1867 def _cb_bookmarkWindowClosed(self, data=None):
1871 self.cbUrlText(url, mode)
1873 def _cmd_on_OpenUrl(self):
1875 if not _g_helper._is_browser_running():
1876 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
1877 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
1879 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1880 def _cmd_on_About(self):
1881 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
1882 def _cmd_on_Exit(self):
1884 def _cmd_on_StartStop(self):
1886 if _g_helper is None:
1888 _g_helper.showBrowserConfigBox()
1889 def _cmd_on_Bookmark(self):
1890 url = self._currentPageUrl
1893 title = self._currentPageTitle
1896 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
1897 def _cmd_on_Preference(self):
1898 url = self._currentPageUrl
1901 self.session.open(OperaBrowserPreferenceWindow, url)
1902 def _cmd_on_OpenStartpage(self):
1904 if not _g_helper._is_browser_running():
1905 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
1906 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
1909 start = 'http://vuplus.com'
1911 d = OperaBrowserSetting().getData()
1915 self.cbUrlText(start, mode)
1916 def _cmd_on_ReturnToBrowser(self):
1919 def _cmd_on_Help(self):
1920 self.session.open(BrowserHelpWindow)
1922 def doCommand(self, command):
1925 cmd_map[_('Exit')] = self._cmd_on_Exit
1926 cmd_map[_('Help')] = self._cmd_on_Help
1927 cmd_map[_('About')] = self._cmd_on_About
1928 cmd_map[_('Open URL')] = self._cmd_on_OpenUrl
1929 cmd_map[_('Start/Stop')] = self._cmd_on_StartStop
1930 cmd_map[_('Bookmark')] = self._cmd_on_Bookmark
1931 cmd_map[_('Preference')] = self._cmd_on_Preference
1932 cmd_map[_('Return')] = self._cmd_on_ReturnToBrowser
1933 cmd_map[_('Open Startpage')] = self._cmd_on_OpenStartpage
1936 except Exception, ErrMsg: print ErrMsg
1939 if not self.toggleListViewFlag:
1942 if self.currentListView.getCurrent()[1] is None:
1943 self.doCommand(self.currentListView.getCurrent()[0])
1944 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
1948 def updateSelectedMenuitem(self, status):
1949 if self.menubarCurrentIndex == 0 and status < 0:
1950 self.menubarCurrentIndex = 2 # modify menu
1951 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
1952 self.menubarCurrentIndex = 0
1953 else: self.menubarCurrentIndex += status
1954 self.selectMenuitem()
1957 if not self.toggleMainScreenFlag:
1959 if not self.toggleListViewFlag:
1960 self.updateSelectedMenuitem(-1)
1962 if self.toggleSubListViewFlag:
1963 self.setCurrentListView(1)
1964 self.toggleSubListView()
1966 #if self.currentListView.getSelectedIndex():
1967 self.currentListView.pageUp()
1973 if not self.toggleMainScreenFlag:
1975 if not self.toggleListViewFlag:
1976 self.updateSelectedMenuitem(1)
1978 if self.currentListView is None:
1980 if self.currentListView.getCurrent()[1] is not None:
1981 parentSelectedIndex = self.currentListView.getSelectedIndex()
1982 self.setCurrentListView(2)
1983 self.currentListView.setList(self.setSubListOnView())
1984 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
1985 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex + self.SUBMENULIST_WIDTH+self.SUBMENULIST_NEXT + 50,self.MENUBAR_ITEM_HEIGHT+30+(parentSelectedIndex*self.SUBMENULIST_HEIGHT))
1986 self.toggleSubListView()
1988 self.currentListView.pageUp()
1994 if not self.toggleMainScreenFlag:
1996 if self.currentListView is None:
1998 if not self.toggleListViewFlag:
1999 self.currentListView.setList(self.setListOnView())
2000 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2001 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2002 self.toggleListView()
2004 self.currentListView.down()
2007 if not self.toggleMainScreenFlag:
2009 if self.currentListView is None:
2011 if self.currentListView == self["menulist"]:
2012 if self.currentListView.getSelectedIndex() == 0:
2013 self.toggleListView()
2015 self.currentListView.up()
2017 def keyCancel(self):
2018 if not self._terminatedBrowser:
2019 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2020 fbClass.getInstance().lock()
2021 eRCInput.getInstance().lock()
2022 if self.toggleListViewFlag:
2023 self.toggleMainScreen()
2024 self._currentPageUrl = None
2025 self._currentPageTitle = None
2026 command_util = getCommandUtil()
2027 command_util.sendCommand('OP_BROWSER_MENU_RES')
2032 self.toggleMainScreen()
2034 def setCurrentPageUrl(self, url, title=None):
2035 self._currentPageUrl = url
2038 if idx > 10: idx = 10
2040 self._currentPageTitle = title
2041 print self._currentPageUrl
2042 self.toggleMainScreen()
2046 def hideSubmenu(self):
2047 self.currentListView.pageUp()
2050 def auto_start_main(reason, **kwargs):
2052 command_server = getCommandServer()
2053 command_server.stop()
2055 from Screens.HelpMenu import HelpableScreen
2056 def session_start_main(session, reason, **kwargs):
2057 fbClass.getInstance().unlock()
2058 eRCInput.getInstance().unlock()
2060 _g_helper = session.open(HbbTVHelper)
2062 HelpableScreen.__init__ = HelpableScreen__init__
2063 HelpableScreen.session = session
2065 def HelpableScreen__init__(self):
2066 if isinstance(self, HelpableScreen):
2067 HelpableScreen.showManual = showManual
2069 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2070 "help_b" : self.showHelp,
2071 "help_l" : self.showManual,
2074 _g_clearBrowserDataTimer = eTimer()
2075 def showManual(self):
2076 if not os.path.exists('/usr/local/manual'):
2079 url = 'file:///usr/local/manual/main.html'
2080 lang = language.getLanguage()
2081 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2082 url = 'file:///usr/local/manual/ru_RU/main.html'
2083 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2084 url = 'file:///usr/local/manual/de_DE/main.html'
2087 _g_clearBrowserDataTimer.stop()
2088 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2090 setPluginBrowser(None)
2091 def clearBrowserData():
2092 _g_clearBrowserDataTimer.callback.append(_do_clean)
2093 _g_clearBrowserDataTimer.start(50)
2094 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2096 def plugin_start_main(session, **kwargs):
2097 #session.open(OperaBrowser)
2099 _g_clearBrowserDataTimer.stop()
2100 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2102 setPluginBrowser(None)
2103 def clearBrowserData():
2104 _g_clearBrowserDataTimer.callback.append(_do_clean)
2105 _g_clearBrowserDataTimer.start(50)
2106 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2108 def plugin_extension_start_application(session, **kwargs):
2110 if _g_helper is None:
2112 _g_helper.showApplicationSelectionBox()
2114 def plugin_extension_browser_config(session, **kwargs):
2116 if _g_helper is None:
2118 _g_helper.showBrowserConfigBox()
2120 def Plugins(path, **kwargs):
2122 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2123 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2124 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2125 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2126 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))