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, ConfigYesNo, 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)
63 def UpdateInfoBar(self):
64 if self.resX == 1024 and self.resY == 720:
67 infobar = InfoBar.instance
68 if infobar._InfoBarShowHide__state != 3:
71 infobar.serviceStarted()
74 __gval__ = GlobalValues()
76 def setDefaultResolution(x, y):
81 def setResolution(xres, yres):
83 if __gval__.resX == 1280 and __gval__.resY == 720:
85 from enigma import gMainDC
86 gMainDC.getInstance().setResolution(xres, yres)
88 def restoreResolution():
90 setResolution(1280, 720)
91 setResolution(__gval__.resX, __gval__.resY)
93 if __gval__.resX == 1280 and __gval__.resY == 720:
95 __gval__.UpdateInfoBar()
97 def setPluginBrowser(browser=None):
99 __gval__.plugin_browser = browser
100 def getPluginBrowser():
102 return __gval__.plugin_browser
104 def getPacketHeaders():
106 return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
108 def setChannelInfo(sid, onid, tsid, name, orgid):
109 if sid is None: sid = 0;
110 if onid is None: onid = 0;
111 if tsid is None: tsid = 0;
112 if name is None: name = "";
113 if orgid is None: orgid = 0;
115 __gval__.channel_info_sid = sid
116 __gval__.channel_info_onid = onid
117 __gval__.channel_info_tsid = tsid
118 __gval__.channel_info_name = name
119 __gval__.channel_info_orgid = orgid
120 print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
121 def getChannelInfos():
123 print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
124 __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
125 return (__gval__.channel_info_sid,
126 __gval__.channel_info_onid,
127 __gval__.channel_info_tsid,
128 __gval__.channel_info_name,
129 __gval__.channel_info_orgid)
133 print "Need Restart(GET) : ", __gval__.need_restart
134 return __gval__.need_restart
135 def setNeedRestart(n):
137 __gval__.need_restart = n
138 print "Need Restart(SET) : ", __gval__.need_restart
140 def getCommandUtil():
142 return __gval__.command_util
143 def getCommandServer():
145 return __gval__.command_server
147 def setBeforeService(s):
149 __gval__.before_service = s
150 def getBeforeService():
152 return __gval__.before_service
154 def _unpack(packed_data):
155 (mg, h, hlen) = getPacketHeaders()
157 if strIsEmpty(packed_data):
159 (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
164 d = packed_data[hlen:hlen+l]
167 def _pack(opcode, params=None, reserved=0):
168 (m, h, hlen) = getPacketHeaders()
169 if strIsEmpty(params):
171 packed_data = struct.pack(h, m, opcode, len(params), reserved)
172 return packed_data + params
178 ,'User-Agent: NSPlayer/7.10.0.3059 '
180 ,'Connection: Close '
185 for m in self.headers:
186 self.sendmsg += m + '\n'
187 self.sendmsg += '\n\n'
189 def request(self, host, port=80, location='/'):
190 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
191 sock.connect((host, port))
192 sock.send(self.sendmsg%(location, host))
194 #print self.sendmsg%(location, host)
197 res = sock.recv(1024)
203 def parse(self, data):
204 for d in data.splitlines():
205 if d.startswith('Location: '):
209 def getLocationData(self, url):
210 url_list,host,location = None,None,None
212 url = url[url.find(':')+3:]
213 url_list = url.split('/')
215 location = url[len(url_list[0]):]
216 except Exception, err_msg:
219 html = self.request(host=host, location=location)
220 return self.parse(html)
225 "OP_UNKNOWN" : 0x0000
226 ,"OP_HBBTV_EXIT" : 0x0001
227 ,"OP_HBBTV_OPEN_URL" : 0x0002
228 ,"OP_HBBTV_LOAD_AIT" : 0x0003
229 ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
230 ,"OP_HBBTV_FULLSCREEN" : 0x0005
231 ,"OP_HBBTV_TITLE" : 0x0006
232 ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
233 ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
234 ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
235 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
236 ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
237 ,"OP_VOD_URI" : 0x0201
238 ,"OP_VOD_PLAY" : 0x0202
239 ,"OP_VOD_STOP" : 0x0203
240 ,"OP_VOD_PAUSE" : 0x0204
241 ,"OP_VOD_STATUS" : 0x0205
242 ,"OP_VOD_FORBIDDEN" : 0x0206
243 ,"OP_VOD_STOPED" : 0x0207
244 ,"OP_VOD_SPEED_CTRL" : 0x0208
245 ,"OP_VOD_SEEK_CTRL" : 0x0209
246 ,"OP_BROWSER_OPEN_URL" : 0x0301
247 ,"OP_BROWSER_VKBD_REQ" : 0x0309
248 ,"OP_BROWSER_VKBD_RES" : 0x030A
249 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
250 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
251 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
252 ,"OP_BROWSER_MENU_REQ" : 0x030E
253 ,"OP_BROWSER_MENU_RES" : 0x030F
254 ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
255 ,"OP_DVBAPP_VOL_UP" : 0x0401
256 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
257 ,"OP_DVBAPP_SET_VOL" : 0x0403
258 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
259 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
260 ,"OP_VIDEOBACKEND_ENABLE" : 0x0601
261 ,"OP_VIDEOBACKEND_DISABLE" : 0x0602
262 ,"OP_BROWSER_OPEN_YOUTUBETV" : 0x0603
265 0x0000 : "OP_UNKNOWN"
266 ,0x0001 : "OP_HBBTV_EXIT"
267 ,0x0002 : "OP_HBBTV_OPEN_URL"
268 ,0x0003 : "OP_HBBTV_LOAD_AIT"
269 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
270 ,0x0005 : "OP_HBBTV_FULLSCREEN"
271 ,0x0006 : "OP_HBBTV_TITLE"
272 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
273 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
274 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
275 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
276 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
277 ,0x0201 : "OP_VOD_URI"
278 ,0x0202 : "OP_VOD_PLAY"
279 ,0x0203 : "OP_VOD_STOP"
280 ,0x0204 : "OP_VOD_PAUSE"
281 ,0x0205 : "OP_VOD_STATUS"
282 ,0x0206 : "OP_VOD_FORBIDDEN"
283 ,0x0207 : "OP_VOD_STOPED"
284 ,0x0208 : "OP_VOD_SPEED_CTRL"
285 ,0x0209 : "OP_VOD_SEEK_CTRL"
286 ,0x0301 : "OP_BROWSER_OPEN_URL"
287 ,0x0309 : "OP_BROWSER_VKBD_REQ"
288 ,0x030A : "OP_BROWSER_VKBD_RES"
289 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
290 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
291 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
292 ,0x030E : "OP_BROWSER_MENU_REQ"
293 ,0x030F : "OP_BROWSER_MENU_RES"
294 ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
295 ,0x0401 : "OP_DVBAPP_VOL_UP"
296 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
297 ,0x0403 : "OP_DVBAPP_SET_VOL"
298 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
299 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
300 ,0x0601 : "OP_VIDEOBACKEND_ENABLE"
301 ,0x0602 : "OP_VIDEOBACKEND_DISABLE"
302 ,0x0603 : "OP_BROWSER_OPEN_YOUTUBETV"
305 def get(self, opstr):
307 return self._opcode_[opstr]
309 return self._opcode_["OP_UNKNOWN"]
311 def what(self, opcode):
313 return self._opstr_[opcode]
315 return self._opstr_["0x0000"]
328 def __init__(self, params):
329 self._protocol = params.protocol
330 self._type = params.type
331 self._addr = params.addr
332 self._buf_size = params.buf_size
333 self._handler = params.handler
334 self._timeout = params.timeout
335 self._destroy = params.destroy
337 self._terminated = False
338 self._server_thread = None
340 self.onHbbTVCloseCB = []
341 self.onSetPageTitleCB = []
344 if self._destroy is not None:
345 self._destroy(self._addr)
348 self._terminated = True
349 if self._server_thread is not None:
350 self._server_thread.join()
351 self._server_thread = None
354 self._socket = socket.socket(self._protocol, self._type)
355 self._socket.settimeout(self._timeout)
356 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
357 self._socket.bind(self._addr)
358 self._socket.listen(True)
360 self._server_thread = threading.Thread(target=self._listen)
361 self._server_thread.start()
364 select_list = [self._socket]
367 conn, addr = self._socket.accept()
368 self._client(conn, addr)
369 except Exception, ErrMsg:
370 print "ServerSocket Error >>", ErrMsg
373 while not self._terminated:
374 readable, writable, errored = select.select(select_list, [], [], self._timeout)
376 if s is self._socket:
379 def _client(self, conn, addr):
382 received_data = conn.recv(self._buf_size)
383 if self._handler is not None and not strIsEmpty(received_data):
384 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
385 self._send(conn, send_data)
386 except Exception, ErrMsg:
389 if self._handler is not None:
390 self._handler.printError(ErrMsg)
391 def _send(self, conn, data) :
396 def doListenUnixTCP(self, name, handler):
400 if os.path.exists(name):
402 print "Removed ", name
406 params = SocketParams()
407 params.protocol = socket.AF_UNIX
408 params.type = socket.SOCK_STREAM
410 params.handler = handler
411 params.destroy = destroy
413 streamServer = StreamServer(params)
417 def doListenInetTCP(self, ip, port, handler):
418 print "Not implemented yet!!"
419 def doListenUnixDGRAM(self, name, handler):
420 print "Not implemented yet!!"
421 def doListenInetDGRAM(self, ip, port, handler):
422 print "Not implemented yet!!"
425 def doUnpack(self, data):
428 def doPack(self, opcode, params, reserved=0):
429 return _pack(opcode, params, reserved)
431 def doHandle(self, data, onCloseCB):
432 opcode, params = 0x0, 'Invalid Request!!'
433 return _pack(opcode, params)
435 def printError(self, reason):
438 class BrowserCommandUtil(OpCodeSet):
441 OpCodeSet.__init__(self)
443 def isConnected(self):
448 def doConnect(self, filename):
449 if not os.path.exists(filename):
450 print "File not exists :", filename
453 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
455 print "Fail to open file :", filename
457 except Exception, ErrMsg:
463 def doDisconnect(self):
469 def doSend(self, command, params=None, reserved=0):
471 print "No found pipe!!"
475 data = _pack(self.get(command), params, reserved)
478 os.write(self._fd, data)
479 print "Send OK!! :", command
483 def sendCommand(self, command, params=None, reserved=0):
484 if not self.isConnected():
486 self.doConnect(COMMAND_PATH)
487 result = self.doSend(command, params, reserved)
491 class HandlerHbbTV(Handler):
493 def __init__(self, session):
494 self._session = session
495 self.opcode = OpCodeSet()
497 0x0001 : self._cb_handleCloseHbbTVBrowser
498 ,0x0006 : self._cb_handleSetPageTitle
499 ,0x0009 : self._cb_handleHbbTVRetryOpen
500 ,0x000A : self._cb_handleHbbTVChangeChannel
501 ,0x0101 : self._cb_handleGetChannelInfoForUrl
502 ,0x0102 : self._cb_handleGetChannelInfoForAIT
503 ,0x0103 : self._cb_handleGetChannelInfoList
504 ,0x0201 : self._cb_handleVODPlayerURI
505 ,0x0202 : self._cb_handleVODPlayerPlay
506 ,0x0203 : self._cb_handleVODPlayerStop
507 ,0x0204 : self._cb_handleVODPlayerPlayPause
508 ,0x0401 : self._cb_handleDVBAppVolUp
509 ,0x0402 : self._cb_handleDVBAppVolDown
510 ,0x0403 : self._cb_handleDVBAppSetVol
511 ,0x0208 : self._cb_handleVODSpeedCtrl
512 ,0x0209 : self._cb_handleVODSeekCtrl
513 ,0x0501 : self._cb_handleSystemOutOfMemory
514 ,0x0502 : self._cb_handleSystemNotufyMyPID
515 ,0x0309 : self._cb_handleShowVirtualKeyboard
516 ,0x030B : self._cb_handlePasteVirtualKeyboard
517 ,0x030E : self._cb_handleBrowserMenuReq
518 ,0x0601 : self._cb_handleVideobackendEnable
519 ,0x0602 : self._cb_handleVideobackendDisable
521 self._on_close_cb = None
522 self._on_set_title_cb = None
526 self._retry_open_url = None
527 self._timer_retry_open = eTimer()
528 self._timer_paste_vkbd = eTimer()
529 self._curren_title = None
531 def _handle_dump(self, handle, opcode, data=None):
535 print " - opcode : ", self.opcode.what(opcode)
537 print " - data : ", data
539 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
540 opcode, params, reserved = None, None, 0
541 self._on_close_cb = onCloseCB
542 self._on_set_title_cb = onSetPageTitleCB
544 datas = self.doUnpack(data)
545 except Exception, ErrMsg:
546 print "Unpacking packet ERR :", ErrMsg
547 params = 'fail to unpack packet!!'
548 opcode = self.opcode.get("OP_UNKNOWN")
549 return self.doPack(opcode, params)
553 self.opcode.what(opcode)
556 #print self.handle_map[opcode]
557 (reserved, params) = self.handle_map[opcode](opcode, params)
558 except Exception, ErrMsg:
559 print "Handling packet ERR :", ErrMsg
560 params = 'fail to handle packet!!'
561 opcode = self.opcode.get("OP_UNKNOWN")
562 return self.doPack(opcode, params)
563 self._on_close_cb = None
564 self._on_set_title_cb = None
565 return self.doPack(opcode, params, reserved)
567 def _cb_handleVideobackendEnable(self, opcode, data):
568 self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
569 service = self._session.nav.getCurrentlyPlayingServiceReference()
570 setBeforeService(service)
571 self._session.nav.stopService()
574 def _cb_handleVideobackendDisable(self, opcode, data):
575 self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
576 before_service = getBeforeService()
577 self._session.nav.playService(before_service)
580 def _cb_handleHbbTVChangeChannel(self, opcode, data):
581 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
583 if _g_helper is None:
585 dataItems = data.split(":")
588 if not _g_helper.doChangeChannel(sid, tsid):
592 def _cb_handleBrowserMenuReq(self, opcode, data):
593 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
595 fbClass.getInstance().unlock()
596 eRCInput.getInstance().unlock()
597 browser = getPluginBrowser()
598 if browser is not None:
599 browser.setCurrentPageUrl(data, self._curren_title)
602 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
603 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
604 def _cb_PasteRefocusVirtualKeyboard():
605 self._timer_paste_vkbd.stop()
606 command_util = getCommandUtil()
607 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
609 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
611 def _cb_PasteKeyVirtualKeyboard():
612 self._timer_paste_vkbd.stop()
613 command_util = getCommandUtil()
614 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
616 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
618 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
619 self._timer_paste_vkbd.start(100)
620 def _cb_PasteMouseVirtualKeyboard():
621 self._timer_paste_vkbd.stop()
622 command_util = getCommandUtil()
623 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
625 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
627 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
629 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
630 #self._timer_paste_vkbd.start(1000)
631 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
632 self._timer_paste_vkbd.start(50)
635 def _cb_virtualKeyboardClosed(self, data=None):
636 fbClass.getInstance().lock()
637 eRCInput.getInstance().lock()
638 #setResolution(1280, 720)
639 command_util = getCommandUtil()
640 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
642 def _cb_handleShowVirtualKeyboard(self, opcode, data):
643 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
645 fbClass.getInstance().unlock()
646 eRCInput.getInstance().unlock()
647 if data == 0 or strIsEmpty(data):
649 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
652 def _cb_handleVODSeekCtrl(self, opcode, data):
653 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
654 headLen = struct.calcsize('!I')
655 unpackedData = struct.unpack('!I', data[:headLen])
656 seekTime = unpackedData[0]
657 service = self._session.nav.getCurrentService()
658 seekable = service.seek()
659 if seekable is None or not seekable.isCurrentlySeekable():
660 raise Exception("This stream is not support manual seek.")
662 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
665 def _cb_handleHbbTVRetryOpen(self, opcode, data):
666 def _cb_HbbTVRetryOpenURL():
667 self._timer_retry_open.stop()
668 if self._retry_open_url is not None:
669 command_util = getCommandUtil()
670 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
671 self._retry_open_url = None
673 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
675 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
676 headLen = struct.calcsize('!I')
677 unpackedData = struct.unpack('!I', data[:headLen])
678 delayTime = unpackedData[0]
679 restartUrl = data[headLen:]
681 self._retry_open_url = restartUrl.strip()
682 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
683 self._timer_retry_open.start(delayTime*1000)
686 def _cb_handleSystemNotufyMyPID(self, opcode, data):
687 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
690 def _cb_handleSystemOutOfMemory(self, opcode, data):
691 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
695 def _cb_handleVODSpeedCtrl(self, opcode, data):
696 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
697 headLen = struct.calcsize('!I')
698 unpackedData = struct.unpack('!I', data[:headLen])
699 playSpeed = unpackedData[0]
700 service = self._session.nav.getCurrentService()
701 pauseable = service.pause()
704 if pauseable.setFastForward(playSpeed) == -1:
705 pauseable.setFastForward(1)
706 raise Exception("This stream is not support trick play.")
709 def _cb_handleDVBAppVolUp(self, opcode, data):
710 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
711 vcm = VolumeControl.instance
715 def _cb_handleDVBAppVolDown(self, opcode, data):
716 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
717 vcm = VolumeControl.instance
721 def _cb_handleDVBAppSetVol(self, opcode, data):
722 self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data)
724 VolumeControl.instance.volctrl.setVolume(v, v)
727 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
728 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
729 (sid, onid, tsid, name, orgid) = getChannelInfos()
731 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
733 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
734 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
735 (sid, onid, tsid, name, orgid) = getChannelInfos()
737 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
739 def _cb_handleGetChannelInfoList(self, opcode, data):
740 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
741 (sid, onid, tsid, name, orgid) = getChannelInfos()
743 channel_list_size = 1
744 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
746 def _cb_handleSetPageTitle(self, opcode, data):
747 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
748 if data.startswith('file://') or data.startswith('http://'):
750 if self._on_set_title_cb is not None:
751 for x in self._on_set_title_cb:
754 self._curren_title = data
755 except Exception, ErrMsg:
756 if x in self._on_set_title_cb:
757 self._on_set_title_cb.remove(x)
760 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
761 self._timer_retry_open.stop()
763 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
765 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
767 if self._on_close_cb:
768 for x in self._on_close_cb:
771 except Exception, ErrMsg:
772 if x in self._on_close_cb:
773 self._on_close_cb.remove(x)
775 command_util = getCommandUtil()
776 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
778 before_service = getBeforeService()
779 if before_service is not None:
780 self._session.nav.playService(before_service)
786 def _cb_handleVODPlayerURI(self, opcode, data):
788 hl = struct.calcsize('!II')
789 datas = struct.unpack('!II', data[:hl])
791 vodUri = data[hl:hl+uriLength]
792 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
793 self._vod_uri = vodUri
796 def doStop(self, restoreBeforeService=True, needStop=True):
798 self._session.nav.stopService()
799 if self._vod_service is not None and restoreBeforeService:
800 before_service = getBeforeService()
801 self._session.nav.playService(before_service)
803 self._vod_service = None
808 def doRetryOpen(self, url):
812 self._vod_service = None
814 #print "Try to open vod [%d] : %s" % (ii, url)
815 print "Try to open vod"
816 self._vod_service = eServiceReference(4097, 0, url)
817 self._session.nav.playService(self._vod_service)
818 if self._vod_service is not None:
820 except Exception, ErrMsg:
821 print "OpenVOD ERR :", ErrMsg
825 def _cb_handleVODPlayerPlay(self, opcode, data):
826 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
827 self.doStop(restoreBeforeService=False)
828 if self.doRetryOpen(url=self._vod_uri) == False:
832 def _cb_handleVODPlayerStop(self, opcode, data):
833 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
837 def _cb_handleVODPlayerPlayPause(self, opcode, data):
838 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
839 service = self._session.nav.getCurrentService()
842 servicePause = service.pause()
844 servicePause.unpause()
845 elif pauseFlag == 'P':
847 except Exception, ErrMsg:
848 print "onPause ERR :", ErrMsg
851 from libshm import SimpleSharedMemory
853 class HbbTVWindow(Screen, InfoBarNotifications):
855 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
858 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
859 self._session = session
860 setResolution(1280, 720)
861 fbClass.getInstance().lock()
862 eRCInput.getInstance().lock()
864 Screen.__init__(self, session)
865 InfoBarNotifications.__init__(self)
866 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
867 iPlayableService.evUser+20: self._serviceForbiden,
868 iPlayableService.evStart: self._serviceStarted,
869 iPlayableService.evEOF: self._serviceEOF,
873 self._use_ait = useAIT
874 self._profile = profile
875 self._cb_closed_func = cbf
876 self.onLayoutFinish.append(self._layoutFinished)
878 command_server = getCommandServer()
879 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
880 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
882 if self._cb_close_window not in command_server.onHbbTVCloseCB:
883 command_server.onHbbTVCloseCB.append(self._cb_close_window)
885 self._closeTimer = eTimer()
886 self._closeTimer.callback.append(self._do_close)
888 self._currentServicePositionTimer = eTimer()
889 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
896 def getVodPlayTime(self):
898 service = self._session.nav.getCurrentService()
899 seek = service and service.seek()
901 p = seek.getPlayPosition()
902 #return (p[1]/90000, l[1]/90000)
907 def _cb_currentServicePosition(self):
908 def getTimeString(t):
909 t = time.localtime(t/90000)
910 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
911 position,length = 0,0
913 (position,length) = self.getVodPlayTime()
914 self._vod_length = length
915 if position == -1 and length == -1:
916 raise Exception("Can't get play status")
917 #print getTimeString(position), "/", getTimeString(length)
918 self._ssm.setStatus(position, length, 1)
919 except Exception, ErrMsg:
923 def _serviceStarted(self):
925 self._ssm.setStatus(0, 0, 0)
926 self._currentServicePositionTimer.start(1000)
927 except Exception, ErrMsg:
930 def _serviceEOF(self):
931 (position,length) = self.getVodPlayTime()
932 self._ssm.setStatus(length, length, 1)
934 self._currentServicePositionTimer.stop()
936 def _layoutFinished(self):
937 self.setTitle(_('HbbTV Plugin'))
938 command_util = getCommandUtil()
939 profile = self._profile
940 (sid, onid, tsid, name, orgid) = getChannelInfos()
941 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
943 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
945 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
947 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
949 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
951 def _cb_close_window(self):
952 self._closeTimer.start(1000)
955 self._closeTimer.stop()
956 command_server = getCommandServer()
958 if self._cb_set_page_title in command_server.onSetPageTitleCB:
959 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
960 except Exception, ErrMsg: pass
962 if self._cb_close_window in command_server.onHbbTVCloseCB:
963 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
964 except Exception, ErrMsg: pass
966 if self._cb_closed_func is not None:
967 self._cb_closed_func()
970 fbClass.getInstance().unlock()
971 eRCInput.getInstance().unlock()
974 def _serviceForbiden(self):
976 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
977 #print "Received URI :\n", real_url
979 if real_url is not None:
980 __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
982 def _cb_set_page_title(self, title=None):
983 print "page title :",title
988 class HbbTVHelper(Screen):
989 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
990 def __init__(self, session):
992 __gval__.hbbtv_handelr = HandlerHbbTV(session)
993 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
997 Screen.__init__(self, session)
998 self._session = session
1000 self._restart_opera()
1002 self._timer_infobar = eTimer()
1003 self._timer_infobar.callback.append(self._cb_registrate_infobar)
1004 self._timer_infobar.start(1000)
1006 self._excuted_browser = False
1009 __gval__.command_util = BrowserCommandUtil()
1013 _g_ssm_ = SimpleSharedMemory()
1016 self._callbackStartStop = None
1018 def _cb_registrate_infobar(self):
1019 if InfoBar.instance:
1020 self._timer_infobar.stop()
1021 if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
1022 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
1023 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
1024 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
1026 def _cb_ready_for_ait(self, orgId=0):
1028 if not self._excuted_browser:
1029 command_util = getCommandUtil()
1030 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1032 setChannelInfo(None, None, None, None, None)
1034 service = self._session.nav.getCurrentService()
1035 info = service and service.info()
1036 if info is not None:
1037 sid = info.getInfo(iServiceInformation.sSID)
1038 onid = info.getInfo(iServiceInformation.sONID)
1039 tsid = info.getInfo(iServiceInformation.sTSID)
1040 name = info.getName()
1045 for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
1046 if x[0] in (1, -1) :
1049 setChannelInfo(sid, onid, tsid, name, orgid)
1051 def _cb_hbbtv_activated(self, title=None, url=None):
1052 if not self._is_browser_running():
1053 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1054 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1056 service = self._session.nav.getCurrentlyPlayingServiceReference()
1057 setBeforeService(service)
1058 self._start_hbbtv_application(title, url)
1060 def _start_hbbtv_application(self, title, url):
1062 tmp_url = self.getStartHbbTVUrl()
1066 print "can't get url of hbbtv!!"
1068 print "success to get url of hbbtv!! >>", url
1069 if self._excuted_browser:
1070 print "already excuted opera browser!!"
1074 self._restart_opera()
1076 setNeedRestart(False)
1078 for x in self._urls:
1081 if tmp_url == url and control_code == 1:
1083 self._excuted_browser = True
1084 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1086 def _cb_closed_browser(self):
1087 self._excuted_browser = False
1089 def _start_opera(self):
1090 if not self._is_browser_running():
1091 global HBBTVAPP_PATH
1093 start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
1094 os.system(start_command)
1097 def _stop_opera(self):
1098 global HBBTVAPP_PATH
1099 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1102 def _restart_opera(self):
1103 global HBBTVAPP_PATH
1105 try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
1109 def getStartHbbTVUrl(self):
1110 url, self._urls, self._profile = None, None, 0
1111 service = self._session.nav.getCurrentService()
1112 info = service and service.info()
1113 if not info: return None
1114 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1115 for u in self._urls:
1116 if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1118 self._profile = u[5]
1120 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1123 def showApplicationSelectionBox(self):
1126 if self.getStartHbbTVUrl():
1127 for x in self._urls:
1128 applications.append((x[1], x))
1129 else: applications.append((_("No detected HbbTV applications."), None))
1130 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1132 def _application_selected(self, selected):
1134 if selected[1] is None: return
1135 self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1136 except Exception, ErrMsg: print ErrMsg
1138 def showBrowserConfigBox(self, callback=None):
1139 start_stop_mode = []
1140 self._callbackStartStop = callback
1141 if self._is_browser_running():
1142 start_stop_mode.append((_('Stop'),'Stop'))
1143 else: start_stop_mode.append((_('Start'),'Start'))
1144 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1146 def _browser_config_selected(self, selected):
1147 if selected is None:
1149 if self._callbackStartStop is not None:
1150 self._callbackStartStop()
1154 if not self._is_browser_running():
1156 elif mode == 'Stop':
1158 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1160 def _is_browser_running(self):
1162 global HBBTVAPP_PATH
1163 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1164 return ret.strip() != "0"
1165 except Exception, ErrMsg:
1166 print "Check Browser Running ERR :", ErrMsg
1169 def doChangeChannel(self, _sid, _tsid):
1170 root = eServiceReference(service_types_tv)
1173 serviceList = eServiceCenter.getInstance().list(root)
1174 if serviceList is None:
1177 service = serviceList.getNext()
1178 if service is None or not service.valid():
1181 #1:0:19:2840:3FB:1:C00000:0:0:0:
1182 serviceRef = service.toString()
1183 if strIsEmpty(serviceRef):
1185 serviceRefItems = serviceRef.split(":")
1186 if len(serviceRefItems) < 5:
1189 sid = serviceRefItems[3]
1190 tsid = serviceRefItems[4]
1191 if sid == _sid and tsid == _tsid:
1192 self._session.nav.playService(eServiceReference(serviceRef))
1193 service = self._session.nav.getCurrentlyPlayingServiceReference()
1194 setBeforeService(service)
1198 class OperaBrowserSetting:
1200 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1206 f = open(self._settingFileName)
1207 for line in f.readlines():
1208 if line.startswith('start='):
1209 tmp = line[6:len(line)-1].split()
1210 self._start = tmp[0]
1212 self._type = int(tmp[1])
1213 else: self._type = 0
1214 elif line.startswith('keymap='):
1215 self._keymap = line[7:len(line)-1]
1219 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1220 tmpstr.append('keymap=%s\n' % (self._keymap))
1221 f = open(self._settingFileName, 'w')
1222 f.writelines(tmpstr)
1224 def setData(self, start, types=0, keymap="us-rc"):
1227 self._keymap = keymap
1231 'start':self._start,
1233 'keymap':self._keymap,
1236 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1238 <screen position="center,120" size="600,350" title="Preference">
1239 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1240 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1242 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1243 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1245 <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" />
1246 <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" />
1249 def __init__(self, session, currentUrl):
1250 self.session = session
1251 Screen.__init__(self, session)
1254 ConfigListScreen.__init__(self, self.menulist)
1256 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1257 "red" : self.keyRed,
1258 "green" : self.keyGreen,
1260 "cancel" : self.keyRed
1262 self["key_red"] = StaticText(_("Cancel"))
1263 self["key_green"] = StaticText(_("Save"))
1264 self["url"] = Label()
1266 self._currentPageUrl = currentUrl
1267 if self._currentPageUrl is None:
1268 self._currentPageUrl = ''
1269 self._startPageUrl = None
1270 self._keymapType = None
1271 self.makeMenuEntry()
1272 self.onLayoutFinish.append(self.layoutFinished)
1274 def layoutFinished(self):
1275 self.setTitle(_('Preference'))
1277 def updateStartPageUrl(self):
1278 if self.menuItemStartpage.value == "startpage":
1279 self["url"].setText(self._startPageUrl)
1280 elif self.menuItemStartpage.value == "current":
1281 self["url"].setText(self._currentPageUrl)
1282 elif self.menuItemStartpage.value == "direct":
1283 self["url"].setText('')
1286 url = self["url"].getText()
1288 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1291 if url.find('/usr/local/manual') > 0:
1293 self._keymapType = self.menuItemKeyboardLayout.value
1294 OperaBrowserSetting().setData(url, mode, self._keymapType)
1295 command_util = getCommandUtil()
1296 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1303 def _cb_directInputUrl(data):
1304 if strIsEmpty(data):
1306 self["url"].setText(data)
1307 if self.menuItemStartpage.value == "direct":
1308 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1311 ConfigListScreen.keyLeft(self)
1312 self.updateStartPageUrl()
1315 ConfigListScreen.keyRight(self)
1316 self.updateStartPageUrl()
1318 def getKeymapTypeList(self):
1320 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1321 filesplit = f.split('.')
1322 if len(filesplit) < 2:
1324 types.append((filesplit[1], filesplit[1]))
1328 def makeMenuEntry(self):
1330 l.append(("startpage", _("Start Page")))
1331 if not strIsEmpty(self._currentPageUrl):
1332 l.append(("current", _("Current Page")))
1333 l.append(("direct", _("Direct Input")))
1334 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1335 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1337 kl = self.getKeymapTypeList()
1340 d = OperaBrowserSetting().getData()
1341 self._startPageUrl = d['start']
1342 self._keymapType = d['keymap']
1344 except: self._startPageUrl = 'http://vuplus.com'
1345 self.updateStartPageUrl()
1347 if self._keymapType is None or len(self._keymapType) == 0:
1348 self._keymapType = "us-rc"
1349 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1350 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1351 self.resetMenuList()
1353 def resetMenuList(self):
1355 self.menulist.append(self.menuEntryStartpage)
1356 self.menulist.append(self.menuEntryKeyboardLayout)
1358 self["config"].list = self.menulist
1359 self["config"].l.setList(self.menulist)
1361 class BookmarkEditWindow(ConfigListScreen, Screen):
1362 CATEGORY,BOOKMARK = 0,1
1364 <screen position="center,center" size="600,140" title="Bookmark Edit">
1365 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1367 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1368 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1370 <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" />
1371 <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" />
1373 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1377 def __init__(self, session, _mode, _type, _data, _bm):
1381 self.mSession = session
1382 self.mBookmarkManager = _bm
1384 if _data is not None:
1387 Screen.__init__(self, session)
1390 ConfigListScreen.__init__(self, self.menulist)
1392 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1393 "ok" : self.keyGreen,
1394 "green" : self.keyGreen,
1395 "red" : self.keyRed,
1396 "cancel" : self.keyRed,
1399 self["VKeyIcon"] = Pixmap()
1400 self["key_red"] = StaticText(_("Cancel"))
1401 self["key_green"] = StaticText(_("Save"))
1403 self.menuItemTitle = None
1404 self.menuItemUrl = None
1405 self.menuItemName = None
1407 self.menuEntryName = None
1408 self.menuEntryTitle = None
1409 self.menuEntryUrl = None
1411 self.makeConfigList()
1412 self.onLayoutFinish.append(self.layoutFinished)
1414 def layoutFinished(self):
1415 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1417 def selectedItem(self):
1418 currentPosition = self["config"].getCurrent()
1419 if self.mType == BookmarkEditWindow.CATEGORY:
1420 return (_("Name"), self.menuItemName)
1422 if currentPosition == self.menuEntryTitle:
1423 return (_("Title"), self.menuItemTitle)
1424 elif currentPosition == self.menuEntryUrl:
1425 return (_("Url"), self.menuItemUrl)
1428 def showMessageBox(self, text):
1429 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1430 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1433 def showVKeyWindow(self, data=None):
1436 selected = self.selectedItem()
1437 if selected is not None:
1438 itemValue = selected[1].value
1439 if strIsEmpty(itemValue):
1441 itemTitle = selected[0]
1443 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1445 def cbVKeyWindow(self, data=None):
1446 if data is not None:
1447 selected = self.selectedItem()
1448 if selected is not None:
1449 selected[1].setValue(data)
1452 if self.mType == BookmarkEditWindow.CATEGORY:
1453 if self.mMode == _('Add'):
1454 categoryName = self.menuItemName.value
1455 if strIsEmpty(categoryName):
1456 return self.showMessageBox(_("Category Name"))
1457 self.mBookmarkManager.addCategory(categoryName)
1459 if strIsEmpty(self.menuItemName.value):
1460 return self.showMessageBox(_("Category Name"))
1461 self.mData.mName = self.menuItemName.value
1462 self.mBookmarkManager.updateCategory(self.mData)
1464 if self.mMode == _('Add'):
1465 bookmarkTitle = self.menuItemTitle.value
1466 bookmarkUrl = self.menuItemUrl.value
1467 if strIsEmpty(bookmarkTitle):
1468 self["config"].setCurrentIndex(0)
1469 return self.showMessageBox(_("Bookmark Title"))
1470 if strIsEmpty(bookmarkUrl):
1471 self["config"].setCurrentIndex(1)
1472 return self.showMessageBox(_("Bookmark URL"))
1473 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1475 if strIsEmpty(self.menuItemTitle.value):
1476 self["config"].setCurrentIndex(0)
1477 return self.showMessageBox(_("Bookmark Title"))
1478 if strIsEmpty(self.menuItemUrl.value):
1479 self["config"].setCurrentIndex(1)
1480 return self.showMessageBox(_("Bookmark URL"))
1481 self.mData.mTitle = self.menuItemTitle.value
1482 self.mData.mUrl = self.menuItemUrl.value
1483 self.mBookmarkManager.updateBookmark(self.mData)
1487 if not self.saveData():
1493 ConfigListScreen.keyLeft(self)
1495 ConfigListScreen.keyRight(self)
1496 def makeConfigList(self):
1499 if self.mType == BookmarkEditWindow.CATEGORY:
1500 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1502 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1504 self.menulist.append(self.menuEntryName)
1506 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1507 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1509 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1510 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1512 self.menulist.append(self.menuEntryTitle)
1513 self.menulist.append(self.menuEntryUrl)
1515 self["config"].list = self.menulist
1516 self["config"].l.setList(self.menulist)
1518 class OperaBrowserBookmarkWindow(Screen):
1520 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1521 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1523 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1524 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1526 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1527 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1528 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1529 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1531 <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" />
1532 <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" />
1533 <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" />
1534 <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" />
1538 def __init__(self, _session, _url=None, _title=None):
1540 self.mTitle = _title
1541 self.mBookmarkManager = BookmarkManager.getInstance()
1542 self.mSession = _session
1543 Screen.__init__(self, _session)
1544 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1546 "cancel": self.keyCancel,
1547 "red" : self.keyRed,
1548 "green" : self.keyGreen,
1549 "yellow": self.keyYellow,
1550 "blue" : self.keyBlue,
1551 "0" : self.keyNumber,
1554 self["key_red"] = StaticText(_("Exit"))
1555 self["key_green"] = StaticText(_("Add"))
1556 self["key_yellow"] = StaticText(_("Edit"))
1557 self["key_blue"] = StaticText(_("Delete"))
1558 self["key_0"] = StaticText(_("Set as Startpage"))
1560 self.mBookmarkList = self.setBookmarkList()
1561 self["bookmarklist"] = MenuList(self.mBookmarkList)
1563 self.onLayoutFinish.append(self.layoutFinished)
1565 def layoutFinished(self):
1566 self.setTitle(_('Bookmark'))
1568 def setBookmarkList(self):
1570 #self.mBookmarkManager.dump()
1571 cd = self.mBookmarkManager.getBookmarkRoot()
1572 for ck in cd.iterkeys():
1573 l.append(('# ' + cd[ck].mName, cd[ck]))
1574 bd = cd[ck].mBookmarks
1575 for bk in bd.iterkeys():
1576 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1578 def updateBookmarkList(self):
1579 self.mBookmarkList = self.setBookmarkList()
1580 self["bookmarklist"].setList(self.mBookmarkList)
1581 def cbEditWindow(self, ret=False):
1584 self.updateBookmarkList()
1585 def getParentCategory(self):
1586 idx = self["bookmarklist"].getSelectedIndex()
1589 data = self.mBookmarkList[idx][0].strip()
1591 return self.mBookmarkList[idx][1]
1595 def isCategoryItem(self):
1597 head = self["bookmarklist"].getCurrent()[0].strip()
1602 def keyNumber(self):
1603 data = self["bookmarklist"].getCurrent()[1]
1604 if strIsEmpty(data.mUrl):
1605 msg = _("Invalid URL. Please check again!!")
1606 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1608 def cbSetStartpage(ret=None):
1609 if ret is None: return
1611 data = self["bookmarklist"].getCurrent()[1]
1612 OperaBrowserSetting().setData(data.mUrl, data.mType)
1613 msg = _("Do you want to set selected url to the Startpage?")
1614 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1621 parent = self.getParentCategory()
1624 if strIsEmpty(self.mTitle):
1626 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1628 msg = _("Current page is already exist.")
1629 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1630 self.cbEditWindow(True)
1632 parent = self.getParentCategory()
1635 b = BookmarkData(0, '', '', parent.mId, 0)
1636 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1638 c = CategoryData(0, '')
1639 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1640 if strIsEmpty(self.mUrl):
1641 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1642 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1643 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1644 def keyYellow(self):
1645 data = self["bookmarklist"].getCurrent()[1]
1646 if self.isCategoryItem():
1647 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1648 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1650 def cbBlue(ret=None):
1652 data = self["bookmarklist"].getCurrent()[1]
1653 if self.isCategoryItem():
1654 self.mBookmarkManager.deleteCategory(data.mId)
1655 else: self.mBookmarkManager.deleteBookmark(data.mId)
1656 self.updateBookmarkList()
1657 if self.isCategoryItem():
1658 msg = _("Do you want to delete the category and the bookmarks?")
1659 else: msg = _("Do you want to delete the bookmark?")
1660 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1662 if self.isCategoryItem(): return
1664 data = self["bookmarklist"].getCurrent()[1]
1665 url = data.mUrl.strip()
1667 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1671 lang = language.getLanguage()
1672 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1673 url = '/usr/local/manual/ru_RU/main.html'
1674 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1675 url = '/usr/local/manual/de_DE/main.html'
1676 self.close((url, mode))
1679 def keyCancel(self):
1682 class BrowserHelpWindow(Screen, HelpableScreen):
1683 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1685 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1686 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1687 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1688 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1689 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1691 <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" />
1692 <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" />
1693 <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" />
1694 <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" />
1697 def __init__(self, session):
1698 Screen.__init__(self, session)
1699 HelpableScreen.__init__(self)
1701 self["key_red"] = StaticText(_("Exit"))
1702 self["key_green"] = StaticText(_("Global"))
1703 self["key_yellow"] = StaticText(_("Mouse"))
1704 self["key_blue"] = StaticText(_("Keyboard"))
1706 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1708 "cancel": self.keyRed,
1709 "red" : self.keyRed,
1710 "green" : self.keyGreen,
1711 "yellow": self.keyYellow,
1712 "blue" : self.keyBlue,
1715 self.showHelpTimer = eTimer()
1716 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1717 self.showHelpTimer.start(500)
1719 self.onLayoutFinish.append(self.layoutFinished)
1721 def layoutFinished(self):
1722 self.setTitle(_('Browser Help'))
1724 def cbShowHelpTimerClosed(self):
1725 self.showHelpTimer.stop()
1726 self.setHelpModeActions(self.MODE_GLOBAL)
1728 def setHelpModeActions(self, _mode=0):
1730 if _mode == self.MODE_GLOBAL:
1731 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1732 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1734 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1735 "menu" : (self.keyPass, _("Show the Menu window.")),
1737 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1738 "green" : (self.keyPass, _("Enter Key")),
1739 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1740 "blue" : (self.keyPass, _("Backspace Key")),
1742 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1743 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1746 elif _mode == self.MODE_MOUSE:
1747 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1748 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1749 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1750 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1751 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1753 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1754 "ok" : (self.keyPass, _("Left Mouse Button")),
1756 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1757 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1758 "nextService" : (self.keyPass, _("Left Key")),
1759 "prevService" : (self.keyPass, _("Right Key")),
1761 elif _mode == self.MODE_KEYBOARD:
1762 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1763 "up" : (self.keyPass, _("Up Key")),
1764 "down" : (self.keyPass, _("Down Key")),
1765 "left" : (self.keyPass, _("Left Key")),
1766 "right" : (self.keyPass, _("Right Key")),
1768 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1769 "ok" : (self.keyPass, _("Enter Key")),
1771 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1772 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1773 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1774 "nextService" : (self.keyPass, _("Go to previous page.")),
1775 "prevService" : (self.keyPass, _("Go to next page.")),
1787 self.setHelpModeActions(self.MODE_GLOBAL)
1788 def keyYellow(self):
1789 self.setHelpModeActions(self.MODE_MOUSE)
1791 self.setHelpModeActions(self.MODE_KEYBOARD)
1793 class OperaBrowser(Screen):
1794 MENUBAR_ITEM_WIDTH = 150
1795 MENUBAR_ITEM_HEIGHT = 30
1796 SUBMENULIST_WIDTH = 200
1797 SUBMENULIST_HEIGHT = 25
1798 SUBMENULIST_NEXT = 2
1800 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1801 # menulist->size->x : SUBMENULIST_WIDTH
1802 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1803 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1804 # submenulist->size->x : SUBMENULIST_WIDTH
1806 size = getDesktop(0).size()
1807 WIDTH = int(size.width())
1808 HEIGHT = int(size.height())
1810 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1811 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1812 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1813 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1814 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1815 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1816 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1817 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1819 """ % { 'width' :WIDTH,
1821 'bottom_pos_y' :HEIGHT-80,
1822 'bottom_size_x' :WIDTH }
1826 def __init__(self, session, url=None, isWebAppMode=False):
1827 Screen.__init__(self, session)
1828 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1829 "cancel" : self.keyCancel
1831 ,"left" : self.keyLeft
1832 ,"right" : self.keyRight
1834 ,"down" : self.keyDown
1835 ,"menu" : self.keyMenu
1838 self.UpdateLanguageCB()
1840 self._terminatedBrowser = True
1841 self._enableKeyEvent = True
1842 self._currentPageUrl = None
1843 self._currentPageTitle = None
1844 self.menubarCurrentIndex = 0
1845 self.lvMenuItems = []
1846 self.lvSubMenuItems = []
1848 self["topArea"] = Label()
1849 self["bottomArea"] = Label()
1851 self["menuitemFile"] = MultiColorLabel()# modify menu
1852 self["menuitemTool"] = MultiColorLabel()
1853 self["menuitemHelp"] = MultiColorLabel()
1855 self["menulist"] = MenuList(self.setListOnView())
1856 self["submenulist"] = MenuList(self.setSubListOnView())
1858 self.toggleMainScreenFlag = True
1859 self.toggleListViewFlag = False
1860 self.toggleSubListViewFlag = False
1861 self.currentListView = self["menulist"]
1863 self.onLayoutFinish.append(self.layoutFinished)
1865 self._onCloseTimer = eTimer()
1866 self._onCloseTimer.callback.append(self._cb_onClose)
1869 self.paramIsWebAppMode = isWebAppMode
1870 language.addCallback(self.UpdateLanguageCB)
1872 def UpdateLanguageCB(self):
1874 self.MENUITEMS_LIST = [
1875 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1876 [(_('Bookmark'), None), (_('Preference'), None)],
1877 [(_('About'), None), (_('Help'), None)]]
1878 self.COMMAND_MAP = {}
1879 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1880 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1881 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1882 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1883 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1884 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1885 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1886 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1887 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1889 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1890 rcmouse_path = "/proc/stb/fp/mouse"
1891 if os.path.exists(rcmouse_path):
1892 os.system("echo %d > %s" % (mode, rcmouse_path))
1894 def layoutFinished(self):
1895 self["menuitemFile"].setText(_("File"))# modify menu
1896 self["menuitemTool"].setText(_("Tools"))
1897 self["menuitemHelp"].setText(_("Help"))
1899 self["menulist"].hide()
1900 self["submenulist"].hide()
1902 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1903 self.setTitle(_("BrowserMain"))
1904 self.selectMenuitem()
1906 if self.paramUrl is not None:
1908 if self.paramIsWebAppMode:
1909 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1910 else: self.cbUrlText(data=self.paramUrl, mode=1)
1912 def selectMenuitem(self):
1913 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1914 self["menuitemFile"].setForegroundColorNum(0)
1915 self["menuitemTool"].setForegroundColorNum(0)
1916 self["menuitemHelp"].setForegroundColorNum(0)
1917 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1919 def popupCloseAll(self):
1925 def setListOnView(self):
1926 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1927 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1928 l = [(_('Return'), None)]
1929 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1930 return self.lvMenuItems
1932 def setSubListOnView(self):
1933 self.lvSubMenuItems = []
1934 xl = self["menulist"].getCurrent()[1]
1935 if xl is None: return []
1937 self.lvSubMenuItems.append((x,None))
1938 return self.lvSubMenuItems
1940 def toggleMainScreen(self):
1941 if not self.toggleMainScreenFlag:
1944 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1946 def toggleListView(self):
1947 if not self.toggleListViewFlag:
1948 self["menulist"].show()
1949 else: self["menulist"].hide()
1950 self.toggleListViewFlag = not self.toggleListViewFlag
1952 def toggleSubListView(self):
1953 if not self.toggleSubListViewFlag:
1954 self["submenulist"].show()
1955 else: self["submenulist"].hide()
1956 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1958 def setCurrentListView(self, listViewIdx):
1959 if listViewIdx == 0:
1960 self.currentListView = None
1961 elif listViewIdx == 1:
1962 self.currentListView = self["menulist"]
1963 elif listViewIdx == 2:
1964 self.currentListView = self["submenulist"]
1966 def _cb_onClose(self):
1967 self._onCloseTimer.stop()
1968 command_server = getCommandServer()
1970 if self._on_close_window in command_server.onHbbTVCloseCB:
1971 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1972 except Exception, ErrMsg: pass
1974 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1975 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1976 except Exception, ErrMsg: pass
1977 self._on_setPageTitle(_('Opera Browser'))
1978 self.enableRCMouse(False)
1979 self.toggleMainScreen()
1981 fbClass.getInstance().unlock()
1982 eRCInput.getInstance().unlock()
1983 self._terminatedBrowser = True
1984 self._enableKeyEvent = True
1985 #if not self.toggleListViewFlag:
1988 self._currentPageUrl = ''
1989 if self.paramUrl is not None:
1995 def _on_setPageTitle(self, title=None):
1996 print "Title :",title
1999 self.setTitle(title)
2001 def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
2003 if not _g_helper._is_browser_running():
2005 print "Inputed Url :", data, mode
2006 if strIsEmpty(data):
2009 command_server = getCommandServer()
2010 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
2011 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
2012 if self._on_close_window not in command_server.onHbbTVCloseCB:
2013 command_server.onHbbTVCloseCB.append(self._on_close_window)
2014 self.toggleMainScreen()
2015 self.enableRCMouse(True)
2017 fbClass.getInstance().lock()
2018 eRCInput.getInstance().lock()
2020 #setResolution(1280, 720)
2022 command_util = getCommandUtil()
2023 command_util.sendCommand(opcode, data, mode)
2024 self._terminatedBrowser = False
2025 self._enableKeyEvent = False
2027 def _on_close_window(self):
2028 self._onCloseTimer.start(1000)
2030 def _cb_bookmarkWindowClosed(self, data=None):
2035 if not _g_helper._is_browser_running():
2036 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2037 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2039 self.cbUrlText(url, mode)
2041 def _cmd_on_OpenUrl(self):
2043 if not _g_helper._is_browser_running():
2044 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2045 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2047 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2048 def _cmd_on_About(self):
2049 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2050 def _cmd_on_Exit(self):
2052 def _cb_cmdOnStartSTop(self):
2054 def _cmd_on_StartStop(self):
2056 if _g_helper is None:
2058 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2060 def _cmd_on_Bookmark(self):
2061 url = self._currentPageUrl
2064 title = self._currentPageTitle
2067 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2068 def _cmd_on_Preference(self):
2069 url = self._currentPageUrl
2072 self.session.open(OperaBrowserPreferenceWindow, url)
2073 def _cmd_on_OpenStartpage(self):
2075 if not _g_helper._is_browser_running():
2076 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2077 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2080 start = 'http://vuplus.com'
2082 d = OperaBrowserSetting().getData()
2086 self.cbUrlText(start, mode)
2087 def _cmd_on_ReturnToBrowser(self):
2090 def _cmd_on_Help(self):
2091 self.session.open(BrowserHelpWindow)
2093 def doCommand(self, command):
2095 self.COMMAND_MAP[command]()
2096 except Exception, ErrMsg: print ErrMsg
2099 if not self.toggleMainScreenFlag:
2102 if not self.toggleListViewFlag:
2105 if self.currentListView.getCurrent()[1] is None:
2106 self.doCommand(self.currentListView.getCurrent()[0])
2107 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2111 def updateSelectedMenuitem(self, status):
2112 if self.menubarCurrentIndex == 0 and status < 0:
2113 self.menubarCurrentIndex = 2 # modify menu
2114 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2115 self.menubarCurrentIndex = 0
2116 else: self.menubarCurrentIndex += status
2117 self.selectMenuitem()
2120 if not self.toggleMainScreenFlag:
2122 if not self.toggleListViewFlag:
2123 self.updateSelectedMenuitem(-1)
2125 if self.toggleSubListViewFlag:
2126 self.setCurrentListView(1)
2127 self.toggleSubListView()
2129 #if self.currentListView.getSelectedIndex():
2130 self.currentListView.pageUp()
2136 if not self.toggleMainScreenFlag:
2138 if not self.toggleListViewFlag:
2139 self.updateSelectedMenuitem(1)
2141 if self.currentListView is None:
2143 if self.currentListView.getCurrent()[1] is not None:
2144 parentSelectedIndex = self.currentListView.getSelectedIndex()
2145 self.setCurrentListView(2)
2146 self.currentListView.setList(self.setSubListOnView())
2147 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2148 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))
2149 self.toggleSubListView()
2151 self.currentListView.pageUp()
2157 if not self.toggleMainScreenFlag:
2159 if self.currentListView is None:
2161 if not self.toggleListViewFlag:
2162 self.currentListView.setList(self.setListOnView())
2163 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2164 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2165 self.toggleListView()
2167 self.currentListView.down()
2170 if not self.toggleMainScreenFlag:
2172 if self.currentListView is None:
2174 if self.currentListView == self["menulist"]:
2175 if self.currentListView.getSelectedIndex() == 0:
2176 self.toggleListView()
2178 self.currentListView.up()
2180 def keyCancel(self):
2181 if not self._terminatedBrowser:
2182 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2183 fbClass.getInstance().lock()
2184 eRCInput.getInstance().lock()
2185 #setResolution(1280, 720)
2186 if self.toggleListViewFlag:
2187 self.toggleMainScreen()
2188 self._currentPageUrl = None
2189 self._currentPageTitle = None
2190 command_util = getCommandUtil()
2191 command_util.sendCommand('OP_BROWSER_MENU_RES')
2196 self.toggleMainScreen()
2198 def setCurrentPageUrl(self, url, title=None):
2199 self._currentPageUrl = url
2202 if idx > 10: idx = 10
2204 self._currentPageTitle = title
2205 print self._currentPageUrl
2206 self.toggleMainScreen()
2210 def hideSubmenu(self):
2211 self.currentListView.pageUp()
2214 config.plugins.youtubetv = ConfigSubsection()
2215 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2216 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2217 class YoutubeTVWindow(Screen, HelpableScreen):
2219 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2220 <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2221 <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2222 <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2223 <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2224 <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2225 <widget source="key_green" render="Label" position="400,80" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
2226 <widget source="key_yellow" render="Label" position="400,120" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
2229 def __init__(self, session):
2230 Screen.__init__(self, session)
2231 HelpableScreen.__init__(self)
2233 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2234 "cancel": self.keyCancel,
2235 "red" : self.keyCancel,
2236 "green" : self.keyGreen,
2237 "yellow": self.keyYellow,
2240 self["key_green"] = StaticText(_("Start"))
2241 self["key_yellow"] = StaticText(_("Help"))
2243 self["infomation"] = Label()
2244 self["startdesc"] = Label()
2245 self["helpdesc"] = Label()
2247 self.onLayoutFinish.append(self.layoutFinished)
2249 def layoutFinished(self):
2250 self.setTitle(_('Start YouTube TV'))
2251 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2252 self["startdesc" ].setText(_("* Start YouTube TV"))
2253 self["helpdesc" ].setText(_("* RC Help"))
2255 def setHelpModeActions(self):
2257 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2258 "ok" : (self.keyPass, _("Play ther selected the video")),
2259 "cancel": (self.keyPass, _("Exit the YouTube TV")),
2261 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2262 "pageUp" : (self.keyPass, _("Move up")),
2263 "pageDown" : (self.keyPass, _("Move down")),
2264 "prevEvent" : (self.keyPass, _("Move left")),
2265 "nextEvent" : (self.keyPass, _("Move right")),
2267 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2268 "info" : (self.keyPass, _("Search a video")),
2269 "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2270 "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2272 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2273 "play" : (self.keyPass, _("Play current video")),
2274 "pause" : (self.keyPass, _("Pause current video")),
2275 "stop" : (self.keyPass, _("Stop current video")),
2277 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2278 "red" : (self.keyPass, _("Back")),
2284 def keyCancel(self):
2285 config.plugins.youtubetv.showhelp.cancel()
2288 config.plugins.youtubetv.showhelp.save()
2289 config.plugins.youtubetv.save()
2290 config.plugins.save()
2292 def keyYellow(self):
2293 self.setHelpModeActions()
2295 if config.plugins.youtubetv.showhelp.value == True :
2296 config.plugins.youtubetv.showhelp.setValue(False)
2297 else: config.plugins.youtubetv.showhelp.setValue(True)
2299 class YoutubeTVSettings(ConfigListScreen, Screen):
2301 <screen position="center,center" size="600,140" title="YouTube TV Settings">
2302 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2304 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2305 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2307 <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" />
2308 <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" />
2311 def __init__(self, session):
2312 self.session = session
2313 Screen.__init__(self, session)
2316 ConfigListScreen.__init__(self, self.menulist)
2318 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2319 "ok" : self.keyGreen,
2320 "green" : self.keyGreen,
2321 "red" : self.keyRed,
2322 "cancel" : self.keyRed,
2325 self["key_red"] = StaticText(_("Cancel"))
2326 self["key_green"] = StaticText(_("Save"))
2328 self.makeConfigList()
2329 self.onLayoutFinish.append(self.layoutFinished)
2331 def layoutFinished(self):
2332 self.setTitle(_('YouTube TV Settings'))
2335 config.plugins.youtubetv.showhelp.save()
2336 config.plugins.youtubetv.uri.save()
2337 config.plugins.youtubetv.save()
2338 config.plugins.save()
2341 config.plugins.youtubetv.showhelp.cancel()
2342 config.plugins.youtubetv.uri.cancel()
2346 ConfigListScreen.keyLeft(self)
2349 ConfigListScreen.keyRight(self)
2351 def makeConfigList(self):
2353 entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2354 entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Stater again"), config.plugins.youtubetv.showhelp)
2355 self.menulist.append(entryUri)
2356 self.menulist.append(entryShowHelp)
2358 self["config"].list = self.menulist
2359 self["config"].l.setList(self.menulist)
2361 def auto_start_main(reason, **kwargs):
2363 command_server = getCommandServer()
2364 command_server.stop()
2366 from Screens.HelpMenu import HelpableScreen
2367 def session_start_main(session, reason, **kwargs):
2368 fbClass.getInstance().unlock()
2369 eRCInput.getInstance().unlock()
2371 from enigma import getDesktop
2372 desktopSize = getDesktop(0).size()
2373 setDefaultResolution(desktopSize.width(), desktopSize.height())
2376 _g_helper = session.open(HbbTVHelper)
2378 HelpableScreen.__init__ = HelpableScreen__init__
2379 HelpableScreen.session = session
2381 def HelpableScreen__init__(self):
2382 if isinstance(self, HelpableScreen):
2383 HelpableScreen.showManual = showManual
2385 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2386 "help_b" : self.showHelp,
2387 "help_l" : self.showManual,
2390 _g_clearBrowserDataTimer = eTimer()
2391 def showManual(self):
2392 if not os.path.exists('/usr/local/manual'):
2395 url = 'file:///usr/local/manual/main.html'
2396 lang = language.getLanguage()
2397 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2398 url = 'file:///usr/local/manual/ru_RU/main.html'
2399 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2400 url = 'file:///usr/local/manual/de_DE/main.html'
2403 _g_clearBrowserDataTimer.stop()
2404 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2406 setPluginBrowser(None)
2407 def clearBrowserData():
2408 _g_clearBrowserDataTimer.callback.append(_do_clean)
2409 _g_clearBrowserDataTimer.start(50)
2410 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2412 _g_backupSession = None
2413 def showYoutubeTV(session, **kwargs):
2415 _g_clearBrowserDataTimer.stop()
2416 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2418 setPluginBrowser(None)
2419 global _g_backupSession
2421 service = getBeforeService()
2422 if service is not None:
2423 _g_backupSession.nav.playService(eServiceReference(service))
2424 _g_backupSession = None
2425 def clearBrowserData():
2426 _g_clearBrowserDataTimer.callback.append(_do_clean)
2427 _g_clearBrowserDataTimer.start(50)
2428 def cbYoutubeTVClose(ret):
2430 global _g_backupSession
2431 _g_backupSession = session
2432 service = session.nav.getCurrentlyPlayingServiceReference()
2433 if service is not None:
2434 setBeforeService(service.toString())
2435 session.nav.stopService()
2436 else: setBeforeService(service)
2437 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2438 if config.plugins.youtubetv.showhelp.value == True:
2439 cbYoutubeTVClose(True)
2440 else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2442 def youtube_setting_main(session, **kwargs):
2443 session.open(YoutubeTVSettings)
2445 def start_menu_main(menuid, **kwargs):
2446 if menuid == "mainmenu":
2447 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2450 def plugin_start_main(session, **kwargs):
2451 #session.open(OperaBrowser)
2453 _g_clearBrowserDataTimer.stop()
2454 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2456 setPluginBrowser(None)
2457 def clearBrowserData():
2458 _g_clearBrowserDataTimer.callback.append(_do_clean)
2459 _g_clearBrowserDataTimer.start(50)
2460 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2462 def plugin_extension_start_application(session, **kwargs):
2464 if _g_helper is None:
2466 _g_helper.showApplicationSelectionBox()
2468 def plugin_extension_browser_config(session, **kwargs):
2470 if _g_helper is None:
2472 _g_helper.showBrowserConfigBox()
2474 def Plugins(path, **kwargs):
2476 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2477 l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2478 l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2479 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2480 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2481 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2482 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))