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
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
177 "OP_UNKNOWN" : 0x0000
178 ,"OP_HBBTV_EXIT" : 0x0001
179 ,"OP_HBBTV_OPEN_URL" : 0x0002
180 ,"OP_HBBTV_LOAD_AIT" : 0x0003
181 ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
182 ,"OP_HBBTV_FULLSCREEN" : 0x0005
183 ,"OP_HBBTV_TITLE" : 0x0006
184 ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
185 ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
186 ,"OP_HBBTV_ABORT_SIG" : 0x000B
187 ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
188 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
189 ,"OP_OIPF_GET_CHANNEL_INFO_LIST" : 0x0103
190 ,"OP_VOD_URI" : 0x0201
191 ,"OP_VOD_PLAY" : 0x0202
192 ,"OP_VOD_STOP" : 0x0203
193 ,"OP_VOD_PAUSE" : 0x0204
194 ,"OP_VOD_STATUS" : 0x0205
195 ,"OP_VOD_FORBIDDEN" : 0x0206
196 ,"OP_VOD_STOPED" : 0x0207
197 ,"OP_VOD_SPEED_CTRL" : 0x0208
198 ,"OP_VOD_SEEK_CTRL" : 0x0209
199 ,"OP_BROWSER_OPEN_URL" : 0x0301
200 ,"OP_BROWSER_VKBD_REQ" : 0x0309
201 ,"OP_BROWSER_VKBD_RES" : 0x030A
202 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
203 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
204 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
205 ,"OP_BROWSER_MENU_REQ" : 0x030E
206 ,"OP_BROWSER_MENU_RES" : 0x030F
207 ,"OP_BROWSER_NEED_RELOAD_KEYMAP" : 0x0313
208 ,"OP_DVBAPP_VOL_UP" : 0x0401
209 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
210 ,"OP_DVBAPP_SET_VOL" : 0x0403
211 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
212 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
213 ,"OP_VIDEOBACKEND_ENABLE" : 0x0601
214 ,"OP_VIDEOBACKEND_DISABLE" : 0x0602
215 ,"OP_BROWSER_OPEN_YOUTUBETV" : 0x0603
218 0x0000 : "OP_UNKNOWN"
219 ,0x0001 : "OP_HBBTV_EXIT"
220 ,0x0002 : "OP_HBBTV_OPEN_URL"
221 ,0x0003 : "OP_HBBTV_LOAD_AIT"
222 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
223 ,0x0005 : "OP_HBBTV_FULLSCREEN"
224 ,0x0006 : "OP_HBBTV_TITLE"
225 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
226 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
227 ,0x000B : "OP_HBBTV_ABORT_SIG"
228 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
229 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
230 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
231 ,0x0201 : "OP_VOD_URI"
232 ,0x0202 : "OP_VOD_PLAY"
233 ,0x0203 : "OP_VOD_STOP"
234 ,0x0204 : "OP_VOD_PAUSE"
235 ,0x0205 : "OP_VOD_STATUS"
236 ,0x0206 : "OP_VOD_FORBIDDEN"
237 ,0x0207 : "OP_VOD_STOPED"
238 ,0x0208 : "OP_VOD_SPEED_CTRL"
239 ,0x0209 : "OP_VOD_SEEK_CTRL"
240 ,0x0301 : "OP_BROWSER_OPEN_URL"
241 ,0x0309 : "OP_BROWSER_VKBD_REQ"
242 ,0x030A : "OP_BROWSER_VKBD_RES"
243 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
244 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
245 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
246 ,0x030E : "OP_BROWSER_MENU_REQ"
247 ,0x030F : "OP_BROWSER_MENU_RES"
248 ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
249 ,0x0401 : "OP_DVBAPP_VOL_UP"
250 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
251 ,0x0403 : "OP_DVBAPP_SET_VOL"
252 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
253 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
254 ,0x0601 : "OP_VIDEOBACKEND_ENABLE"
255 ,0x0602 : "OP_VIDEOBACKEND_DISABLE"
256 ,0x0603 : "OP_BROWSER_OPEN_YOUTUBETV"
259 def get(self, opstr):
261 return self._opcode_[opstr]
263 return self._opcode_["OP_UNKNOWN"]
265 def what(self, opcode):
267 return self._opstr_[opcode]
269 return self._opstr_["0x0000"]
282 def __init__(self, params):
283 self._protocol = params.protocol
284 self._type = params.type
285 self._addr = params.addr
286 self._buf_size = params.buf_size
287 self._handler = params.handler
288 self._timeout = params.timeout
289 self._destroy = params.destroy
291 self._terminated = False
292 self._server_thread = None
294 self.onHbbTVCloseCB = []
295 self.onSetPageTitleCB = []
298 if self._destroy is not None:
299 self._destroy(self._addr)
302 self._terminated = True
303 if self._server_thread is not None:
304 self._server_thread.join()
305 self._server_thread = None
308 self._socket = socket.socket(self._protocol, self._type)
309 self._socket.settimeout(self._timeout)
310 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
311 self._socket.bind(self._addr)
312 self._socket.listen(True)
314 self._server_thread = threading.Thread(target=self._listen)
315 self._server_thread.start()
318 select_list = [self._socket]
321 conn, addr = self._socket.accept()
322 self._client(conn, addr)
323 except Exception, ErrMsg:
324 print "ServerSocket Error >>", ErrMsg
327 while not self._terminated:
328 readable, writable, errored = select.select(select_list, [], [], self._timeout)
330 if s is self._socket:
333 def _client(self, conn, addr):
336 received_data = conn.recv(self._buf_size)
337 if self._handler is not None and not strIsEmpty(received_data):
338 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
339 self._send(conn, send_data)
340 except Exception, ErrMsg:
343 if self._handler is not None:
344 self._handler.printError(ErrMsg)
345 def _send(self, conn, data) :
350 def doListenUnixTCP(self, name, handler):
353 if os.path.exists(name):
355 print "Removed ", name
359 params = SocketParams()
360 params.protocol = socket.AF_UNIX
361 params.type = socket.SOCK_STREAM
363 params.handler = handler
364 params.destroy = destroy
366 streamServer = StreamServer(params)
370 def doListenInetTCP(self, ip, port, handler):
371 print "Not implemented yet!!"
372 def doListenUnixDGRAM(self, name, handler):
373 print "Not implemented yet!!"
374 def doListenInetDGRAM(self, ip, port, handler):
375 print "Not implemented yet!!"
378 def doUnpack(self, data):
381 def doPack(self, opcode, params, reserved=0):
382 return _pack(opcode, params, reserved)
384 def doHandle(self, data, onCloseCB):
385 opcode, params = 0x0, 'Invalid Request!!'
386 return _pack(opcode, params)
388 def printError(self, reason):
391 class BrowserCommandUtil(OpCodeSet):
394 OpCodeSet.__init__(self)
396 def isConnected(self):
401 def doConnect(self, filename):
402 if not os.path.exists(filename):
403 print "File not exists :", filename
406 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
408 print "Fail to open file :", filename
410 except Exception, ErrMsg:
416 def doDisconnect(self):
422 def doSend(self, command, params=None, reserved=0):
424 print "No found pipe!!"
428 data = _pack(self.get(command), params, reserved)
431 os.write(self._fd, data)
432 print "Send OK!! :", command
436 def sendCommand(self, command, params=None, reserved=0):
437 if not self.isConnected():
439 self.doConnect(COMMAND_PATH)
440 result = self.doSend(command, params, reserved)
444 class HandlerHbbTV(Handler):
446 def __init__(self, session):
447 self._session = session
448 self.opcode = OpCodeSet()
450 0x0001 : self._cb_handleCloseHbbTVBrowser
451 ,0x0006 : self._cb_handleSetPageTitle
452 ,0x0009 : self._cb_handleHbbTVRetryOpen
453 ,0x000A : self._cb_handleHbbTVChangeChannel
454 ,0x000B : self._cb_handleHbbTVAbortSig
455 ,0x0101 : self._cb_handleGetChannelInfoForUrl
456 ,0x0102 : self._cb_handleGetChannelInfoForAIT
457 ,0x0103 : self._cb_handleGetChannelInfoList
458 ,0x0201 : self._cb_handleVODPlayerURI
459 ,0x0202 : self._cb_handleVODPlayerPlay
460 ,0x0203 : self._cb_handleVODPlayerStop
461 ,0x0204 : self._cb_handleVODPlayerPlayPause
462 ,0x0401 : self._cb_handleDVBAppVolUp
463 ,0x0402 : self._cb_handleDVBAppVolDown
464 ,0x0403 : self._cb_handleDVBAppSetVol
465 ,0x0208 : self._cb_handleVODSpeedCtrl
466 ,0x0209 : self._cb_handleVODSeekCtrl
467 ,0x0501 : self._cb_handleSystemOutOfMemory
468 ,0x0502 : self._cb_handleSystemNotufyMyPID
469 ,0x0309 : self._cb_handleShowVirtualKeyboard
470 ,0x030B : self._cb_handlePasteVirtualKeyboard
471 ,0x030E : self._cb_handleBrowserMenuReq
472 ,0x0601 : self._cb_handleVideobackendEnable
473 ,0x0602 : self._cb_handleVideobackendDisable
475 self._on_close_cb = None
476 self._on_set_title_cb = None
480 self._retry_open_url = None
481 self._timer_retry_open = eTimer()
482 self._timer_paste_vkbd = eTimer()
483 self._curren_title = None
484 self._max_volume = -1
485 self._soft_volume = -1
487 def _handle_dump(self, handle, opcode, data=None):
491 print " - opcode : ", self.opcode.what(opcode)
493 print " - data : ", data
495 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
496 opcode, params, reserved = None, None, 0
497 self._on_close_cb = onCloseCB
498 self._on_set_title_cb = onSetPageTitleCB
500 datas = self.doUnpack(data)
501 except Exception, ErrMsg:
502 print "Unpacking packet ERR :", ErrMsg
503 params = 'fail to unpack packet!!'
504 opcode = self.opcode.get("OP_UNKNOWN")
505 return self.doPack(opcode, params)
509 self.opcode.what(opcode)
512 #print self.handle_map[opcode]
513 (reserved, params) = self.handle_map[opcode](opcode, params)
514 except Exception, ErrMsg:
515 print "Handling packet ERR :", ErrMsg
516 params = 'fail to handle packet!!'
517 opcode = self.opcode.get("OP_UNKNOWN")
518 return self.doPack(opcode, params)
519 self._on_close_cb = None
520 self._on_set_title_cb = None
521 return self.doPack(opcode, params, reserved)
523 def _cb_handleVideobackendEnable(self, opcode, data):
524 self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
525 service = self._session.nav.getCurrentlyPlayingServiceReference()
526 setBeforeService(service)
527 self._session.nav.stopService()
530 def _cb_handleVideobackendDisable(self, opcode, data):
531 self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
532 before_service = getBeforeService()
533 if before_service is not None:
534 self._session.nav.playService(before_service)
537 def _cb_handleHbbTVChangeChannel(self, opcode, data):
538 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
540 if _g_helper is None:
542 dataItems = data.split(":")
545 if not _g_helper.doChangeChannel(sid, tsid):
549 def _cb_handleBrowserMenuReq(self, opcode, data):
550 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
552 fbClass.getInstance().unlock()
553 eRCInput.getInstance().unlock()
554 browser = getPluginBrowser()
555 if browser is not None:
556 browser.setCurrentPageUrl(data, self._curren_title)
559 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
560 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
561 def _cb_PasteRefocusVirtualKeyboard():
562 self._timer_paste_vkbd.stop()
563 command_util = getCommandUtil()
564 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
566 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
568 def _cb_PasteKeyVirtualKeyboard():
569 self._timer_paste_vkbd.stop()
570 command_util = getCommandUtil()
571 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
573 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
575 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
576 self._timer_paste_vkbd.start(100)
577 def _cb_PasteMouseVirtualKeyboard():
578 self._timer_paste_vkbd.stop()
579 command_util = getCommandUtil()
580 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
582 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
584 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
586 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
587 #self._timer_paste_vkbd.start(1000)
588 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
589 self._timer_paste_vkbd.start(50)
592 def _cb_virtualKeyboardClosed(self, data=None):
593 fbClass.getInstance().lock()
594 eRCInput.getInstance().lock()
595 #setResolution(1280, 720)
596 command_util = getCommandUtil()
597 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
599 def _cb_handleShowVirtualKeyboard(self, opcode, data):
600 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
602 fbClass.getInstance().unlock()
603 eRCInput.getInstance().unlock()
604 if data == 0 or strIsEmpty(data):
606 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
609 def _cb_handleVODSeekCtrl(self, opcode, data):
610 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
611 headLen = struct.calcsize('!I')
612 unpackedData = struct.unpack('!I', data[:headLen])
613 seekTime = unpackedData[0]
614 service = self._session.nav.getCurrentService()
615 seekable = service.seek()
616 if seekable is None or not seekable.isCurrentlySeekable():
617 raise Exception("This stream is not support manual seek.")
619 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
622 def _cb_handleHbbTVRetryOpen(self, opcode, data):
623 def _cb_HbbTVRetryOpenURL():
624 self._timer_retry_open.stop()
625 if self._retry_open_url is not None:
626 command_util = getCommandUtil()
627 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
628 self._retry_open_url = None
630 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
632 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
633 headLen = struct.calcsize('!I')
634 unpackedData = struct.unpack('!I', data[:headLen])
635 delayTime = unpackedData[0]
636 restartUrl = data[headLen:]
638 self._retry_open_url = restartUrl.strip()
639 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
640 self._timer_retry_open.start(delayTime*1000)
643 def _cb_handleSystemNotufyMyPID(self, opcode, data):
644 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
647 def _cb_handleSystemOutOfMemory(self, opcode, data):
648 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
652 def _cb_handleVODSpeedCtrl(self, opcode, data):
653 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
654 headLen = struct.calcsize('!I')
655 unpackedData = struct.unpack('!I', data[:headLen])
656 playSpeed = unpackedData[0]
657 service = self._session.nav.getCurrentService()
658 pauseable = service.pause()
661 if pauseable.setFastForward(playSpeed) == -1:
662 pauseable.setFastForward(1)
663 raise Exception("This stream is not support trick play.")
666 def SetVolume(self, volume):
667 if self._max_volume < 0:
668 self._max_volume = VolumeControl.instance.volctrl.getVolume()
670 self._max_volume += volume
671 if self._max_volume > 100:
672 self._max_volume = 100
673 elif self._max_volume < 0:
676 if self._soft_volume > 0:
677 v = int((self._max_volume * self._soft_volume) / 100)
678 VolumeControl.instance.volctrl.setVolume(v, v)
679 else: VolumeControl.instance.volctrl.setVolume(self._max_volume, self._max_volume)
681 def _cb_handleDVBAppVolUp(self, opcode, data):
682 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
686 def _cb_handleDVBAppVolDown(self, opcode, data):
687 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
691 def _cb_handleDVBAppSetVol(self, opcode, data):
692 self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data)
693 if self._max_volume < 0:
694 self._max_volume = VolumeControl.instance.volctrl.getVolume()
695 self._soft_volume = int(data)
698 if self._soft_volume > 0 and self._max_volume > 0:
699 v = int((self._max_volume * self._soft_volume) / 100)
700 VolumeControl.instance.volctrl.setVolume(v, v)
703 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
704 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
705 (sid, onid, tsid, name, orgid) = getChannelInfos()
707 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
709 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
710 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
711 (sid, onid, tsid, name, orgid) = getChannelInfos()
713 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
715 def _cb_handleGetChannelInfoList(self, opcode, data):
716 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
717 (sid, onid, tsid, name, orgid) = getChannelInfos()
719 channel_list_size = 1
720 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
722 def _cb_handleSetPageTitle(self, opcode, data):
723 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
724 if data.startswith('file://') or data.startswith('http://'):
726 if self._on_set_title_cb is not None:
727 for x in self._on_set_title_cb:
730 self._curren_title = data
731 except Exception, ErrMsg:
732 if x in self._on_set_title_cb:
733 self._on_set_title_cb.remove(x)
736 def _cb_handleHbbTVAbortSig(self, opcode, data):
737 self._cb_handleCloseHbbTVBrowser(opcode, data)
739 return (0, struct.pack('!II', __gval__.resX, __gval__.resY));
741 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
742 self._timer_retry_open.stop()
744 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
746 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
748 if self._on_close_cb:
749 for x in self._on_close_cb:
752 except Exception, ErrMsg:
753 if x in self._on_close_cb:
754 self._on_close_cb.remove(x)
756 command_util = getCommandUtil()
757 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
758 before_service = getBeforeService()
759 if before_service is not None:
760 self._session.nav.playService(before_service)
766 def _cb_handleVODPlayerURI(self, opcode, data):
768 hl = struct.calcsize('!II')
769 datas = struct.unpack('!II', data[:hl])
771 vodUri = data[hl:hl+uriLength]
772 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
773 self._vod_uri = vodUri
776 def doStop(self, restoreBeforeService=True, needStop=True):
778 self._session.nav.stopService()
779 if self._vod_service is not None and restoreBeforeService:
780 before_service = getBeforeService()
781 self._session.nav.playService(before_service)
783 self._vod_service = None
788 def doRetryOpen(self, url):
792 self._vod_service = None
794 #print "Try to open vod [%d] : %s" % (ii, url)
795 print "Try to open vod"
796 self._vod_service = eServiceReference(4097, 0, url)
797 self._session.nav.playService(self._vod_service)
798 if self._vod_service is not None:
800 except Exception, ErrMsg:
801 print "OpenVOD ERR :", ErrMsg
805 def _cb_handleVODPlayerPlay(self, opcode, data):
806 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
807 self.doStop(restoreBeforeService=False)
808 if self.doRetryOpen(url=self._vod_uri) == False:
812 def _cb_handleVODPlayerStop(self, opcode, data):
813 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
817 def _cb_handleVODPlayerPlayPause(self, opcode, data):
818 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
819 service = self._session.nav.getCurrentService()
822 servicePause = service.pause()
824 servicePause.unpause()
825 elif pauseFlag == 'P':
827 except Exception, ErrMsg:
828 print "onPause ERR :", ErrMsg
831 from libshm import SimpleSharedMemory
833 class HbbTVWindow(Screen, InfoBarNotifications):
835 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
838 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
839 self._session = session
840 setResolution(1280, 720)
841 fbClass.getInstance().lock()
842 eRCInput.getInstance().lock()
844 Screen.__init__(self, session)
845 InfoBarNotifications.__init__(self)
846 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
847 iPlayableService.evStart: self._serviceStarted,
848 iPlayableService.evEOF: self._serviceEOF,
852 self._use_ait = useAIT
853 self._profile = profile
854 self._cb_closed_func = cbf
855 self.onLayoutFinish.append(self._layoutFinished)
857 command_server = getCommandServer()
858 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
859 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
861 if self._cb_close_window not in command_server.onHbbTVCloseCB:
862 command_server.onHbbTVCloseCB.append(self._cb_close_window)
864 self._closeTimer = eTimer()
865 self._closeTimer.callback.append(self._do_close)
867 self._currentServicePositionTimer = eTimer()
868 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
875 def getVodPlayTime(self):
877 service = self._session.nav.getCurrentService()
878 seek = service and service.seek()
880 p = seek.getPlayPosition()
881 if(not l[0] and not p[0]):
887 def _cb_currentServicePosition(self):
888 def getTimeString(t):
889 t = time.localtime(t/90000)
890 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
891 position,length = 0,0
893 (position,length) = self.getVodPlayTime()
894 self._vod_length = length
895 if position == -1 and length == -1:
896 raise Exception("Can't get play status")
897 #print position, "/", length, " - ", getTimeString(position), "/", getTimeString(length)
898 self._ssm.setStatus(position, length, 1)
899 except Exception, ErrMsg:
903 def _serviceStarted(self):
905 self._ssm.setStatus(0, 0, 0)
906 self._currentServicePositionTimer.start(1000)
907 except Exception, ErrMsg:
910 def _serviceEOF(self):
911 (position,length) = self.getVodPlayTime()
912 self._ssm.setStatus(length, length, 1)
914 self._currentServicePositionTimer.stop()
916 def _layoutFinished(self):
918 __gval__.hbbtv_handelr._soft_volume = -1
919 self.setTitle(_('HbbTV Plugin'))
920 command_util = getCommandUtil()
921 profile = self._profile
922 (sid, onid, tsid, name, orgid) = getChannelInfos()
923 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
925 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
927 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
929 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
931 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
933 def _cb_close_window(self):
934 self._closeTimer.start(1000)
937 self._closeTimer.stop()
938 command_server = getCommandServer()
940 if self._cb_set_page_title in command_server.onSetPageTitleCB:
941 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
942 except Exception, ErrMsg: pass
944 if self._cb_close_window in command_server.onHbbTVCloseCB:
945 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
946 except Exception, ErrMsg: pass
948 if self._cb_closed_func is not None:
949 self._cb_closed_func()
952 fbClass.getInstance().unlock()
953 eRCInput.getInstance().unlock()
956 def _cb_set_page_title(self, title=None):
957 print "page title :",title
962 class HbbTVHelper(Screen, InfoBarNotifications):
963 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
964 def __init__(self, session):
966 __gval__.hbbtv_handelr = HandlerHbbTV(session)
967 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
969 Screen.__init__(self, session)
970 InfoBarNotifications.__init__(self)
972 self._session = session
974 self._restart_opera()
976 self._timer_infobar = eTimer()
977 self._timer_infobar.callback.append(self._cb_registrate_infobar)
978 self._timer_infobar.start(1000)
980 self._excuted_browser = False
983 __gval__.command_util = BrowserCommandUtil()
987 _g_ssm_ = SimpleSharedMemory()
990 self._callbackStartStop = None
992 self.__et = ServiceEventTracker(screen=self, eventmap={
993 iPlayableService.evHBBTVInfo: self._cb_detectedAIT,
994 iPlayableService.evUpdatedInfo: self._cb_updateInfo
996 self._applicationList = None
998 self.mVuplusBox = False
999 issue = open("/etc/issue").read()
1000 if(issue.startswith("Vuplus")):
1001 self.mVuplusBox = True
1003 def _cb_detectedAIT(self):
1004 name = self._cb_ready_for_ait()
1005 if name is not None and self.mVuplusBox:
1006 from Screens.InfoBarGenerics import gHbbtvApplication
1007 gHbbtvApplication.setApplicationName(str(name))
1009 def _cb_updateInfo(self):
1010 if not self._excuted_browser:
1011 command_util = getCommandUtil()
1012 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1014 from Screens.InfoBarGenerics import gHbbtvApplication
1015 gHbbtvApplication.setApplicationName("")
1016 #self._applicationList = None
1018 def _cb_registrate_infobar(self):
1019 if InfoBar.instance:
1020 self._timer_infobar.stop()
1021 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
1022 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
1024 def _cb_ready_for_ait(self):
1025 setChannelInfo(None, None, None, None, None)
1027 service = self._session.nav.getCurrentService()
1028 info = service and service.info()
1029 if info is not None:
1030 sid = info.getInfo(iServiceInformation.sSID)
1031 onid = info.getInfo(iServiceInformation.sONID)
1032 tsid = info.getInfo(iServiceInformation.sTSID)
1033 name = info.getName()
1037 pmtid = info.getInfo(iServiceInformation.sPMTPID)
1038 demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
1040 from aitreader import eAITSectionReader
1041 reader = eAITSectionReader(demux, pmtid, sid)
1042 if reader.doOpen(info, self.mVuplusBox):
1043 reader.doParseApplications()
1045 else: print "no data!!"
1048 self._applicationList = reader.getApplicationList()
1049 if len(self._applicationList) > 0:
1050 orgid = int(self._applicationList[0]["orgid"])
1051 setChannelInfo(sid, onid, tsid, name, orgid)
1052 return self._applicationList[0]["name"]
1056 def _cb_hbbtv_activated(self, title=None, url=None):
1057 if not self._is_browser_running():
1058 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1059 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1061 service = self._session.nav.getCurrentlyPlayingServiceReference()
1062 setBeforeService(service)
1063 self._start_hbbtv_application(title, url)
1065 def _start_hbbtv_application(self, title, url):
1067 tmp_url = self.getStartHbbTVUrl()
1071 print "can't get url of hbbtv!!"
1073 print "success to get url of hbbtv!! >>", url
1074 if self._excuted_browser:
1075 print "already excuted opera browser!!"
1079 self._restart_opera()
1081 setNeedRestart(False)
1083 for x in self._applicationList:
1084 control_code = int(x["control"])
1086 if tmp_url == url and control_code == 1:
1088 self._excuted_browser = True
1089 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1091 def _cb_closed_browser(self):
1092 self._excuted_browser = False
1094 def _start_opera(self):
1095 if not self._is_browser_running():
1096 global HBBTVAPP_PATH
1098 start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
1099 os.system(start_command)
1102 def _stop_opera(self):
1103 global HBBTVAPP_PATH
1104 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1108 def _restart_opera(self):
1109 global HBBTVAPP_PATH
1111 try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
1115 def getStartHbbTVUrl(self):
1116 url, self._profile = None, 0
1117 if self._applicationList is not None:
1118 for u in self._applicationList:
1119 if u["control"] in (1, -1):
1121 self._profile = u["profile"]
1123 service = self._session.nav.getCurrentService()
1124 info = service and service.info()
1126 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1129 def showApplicationSelectionBox(self):
1132 if self.getStartHbbTVUrl():
1133 for x in self._applicationList:
1134 applications.append((x["name"], x))
1135 else: applications.append((_("No detected HbbTV applications."), None))
1136 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1138 def _application_selected(self, selected):
1141 if selected[1] is None: return
1142 self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
1143 except Exception, ErrMsg: print ErrMsg
1145 def showBrowserConfigBox(self, callback=None):
1146 start_stop_mode = []
1147 self._callbackStartStop = callback
1148 if self._is_browser_running():
1149 start_stop_mode.append((_('Stop'),'Stop'))
1150 else: start_stop_mode.append((_('Start'),'Start'))
1151 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1153 def _browser_config_selected(self, selected):
1154 if selected is None:
1156 if self._callbackStartStop is not None:
1157 self._callbackStartStop()
1161 if not self._is_browser_running():
1163 elif mode == 'Stop':
1165 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1167 def _is_browser_running(self):
1169 global HBBTVAPP_PATH
1170 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1171 return ret.strip() != "0"
1172 except Exception, ErrMsg:
1173 print "Check Browser Running ERR :", ErrMsg
1176 def doChangeChannel(self, _sid, _tsid):
1177 root = eServiceReference(service_types_tv)
1180 serviceList = eServiceCenter.getInstance().list(root)
1181 if serviceList is None:
1184 service = serviceList.getNext()
1185 if service is None or not service.valid():
1188 #1:0:19:2840:3FB:1:C00000:0:0:0:
1189 serviceRef = service.toString()
1190 if strIsEmpty(serviceRef):
1192 serviceRefItems = serviceRef.split(":")
1193 if len(serviceRefItems) < 5:
1196 sid = serviceRefItems[3]
1197 tsid = serviceRefItems[4]
1198 if sid == _sid and tsid == _tsid:
1199 self._session.nav.playService(eServiceReference(serviceRef))
1200 service = self._session.nav.getCurrentlyPlayingServiceReference()
1201 setBeforeService(service)
1205 class OperaBrowserSetting:
1207 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1213 f = open(self._settingFileName)
1214 for line in f.readlines():
1215 if line.startswith('start='):
1216 tmp = line[6:len(line)-1].split()
1217 self._start = tmp[0]
1219 self._type = int(tmp[1])
1220 else: self._type = 0
1221 elif line.startswith('keymap='):
1222 self._keymap = line[7:len(line)-1]
1226 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1227 tmpstr.append('keymap=%s\n' % (self._keymap))
1228 f = open(self._settingFileName, 'w')
1229 f.writelines(tmpstr)
1231 def setData(self, start, types=0, keymap="us-rc"):
1234 self._keymap = keymap
1238 'start':self._start,
1240 'keymap':self._keymap,
1243 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1245 <screen position="center,120" size="600,350" title="Preference">
1246 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1247 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1249 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1250 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1252 <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" />
1253 <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" />
1256 def __init__(self, session, currentUrl):
1257 self.session = session
1258 Screen.__init__(self, session)
1261 ConfigListScreen.__init__(self, self.menulist)
1263 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1264 "red" : self.keyRed,
1265 "green" : self.keyGreen,
1267 "cancel" : self.keyRed
1269 self["key_red"] = StaticText(_("Cancel"))
1270 self["key_green"] = StaticText(_("Save"))
1271 self["url"] = Label()
1273 self._currentPageUrl = currentUrl
1274 if self._currentPageUrl is None:
1275 self._currentPageUrl = ''
1276 self._startPageUrl = None
1277 self._keymapType = None
1278 self.makeMenuEntry()
1279 self.onLayoutFinish.append(self.layoutFinished)
1281 def layoutFinished(self):
1282 self.setTitle(_('Preference'))
1284 def updateStartPageUrl(self):
1285 if self.menuItemStartpage.value == "startpage":
1286 self["url"].setText(self._startPageUrl)
1287 elif self.menuItemStartpage.value == "current":
1288 self["url"].setText(self._currentPageUrl)
1289 elif self.menuItemStartpage.value == "direct":
1290 self["url"].setText('')
1293 url = self["url"].getText()
1295 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1298 if url.find('/usr/local/manual') > 0:
1300 self._keymapType = self.menuItemKeyboardLayout.value
1301 OperaBrowserSetting().setData(url, mode, self._keymapType)
1302 command_util = getCommandUtil()
1303 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1310 def _cb_directInputUrl(data):
1311 if strIsEmpty(data):
1313 self["url"].setText(data)
1314 if self.menuItemStartpage.value == "direct":
1315 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1318 ConfigListScreen.keyLeft(self)
1319 self.updateStartPageUrl()
1322 ConfigListScreen.keyRight(self)
1323 self.updateStartPageUrl()
1325 def getKeymapTypeList(self):
1327 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1328 filesplit = f.split('.')
1329 if len(filesplit) < 2:
1331 types.append((filesplit[1], filesplit[1]))
1335 def makeMenuEntry(self):
1337 l.append(("startpage", _("Start Page")))
1338 if not strIsEmpty(self._currentPageUrl):
1339 l.append(("current", _("Current Page")))
1340 l.append(("direct", _("Direct Input")))
1341 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1342 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1344 kl = self.getKeymapTypeList()
1347 d = OperaBrowserSetting().getData()
1348 self._startPageUrl = d['start']
1349 self._keymapType = d['keymap']
1351 except: self._startPageUrl = 'http://vuplus.com'
1352 self.updateStartPageUrl()
1354 if self._keymapType is None or len(self._keymapType) == 0:
1355 self._keymapType = "us-rc"
1356 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1357 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1358 self.resetMenuList()
1360 def resetMenuList(self):
1362 self.menulist.append(self.menuEntryStartpage)
1363 self.menulist.append(self.menuEntryKeyboardLayout)
1365 self["config"].list = self.menulist
1366 self["config"].l.setList(self.menulist)
1368 class BookmarkEditWindow(ConfigListScreen, Screen):
1369 CATEGORY,BOOKMARK = 0,1
1371 <screen position="center,center" size="600,140" title="Bookmark Edit">
1372 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1374 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1375 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1377 <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" />
1378 <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" />
1380 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1384 def __init__(self, session, _mode, _type, _data, _bm):
1388 self.mSession = session
1389 self.mBookmarkManager = _bm
1391 if _data is not None:
1394 Screen.__init__(self, session)
1397 ConfigListScreen.__init__(self, self.menulist)
1399 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1400 "ok" : self.keyGreen,
1401 "green" : self.keyGreen,
1402 "red" : self.keyRed,
1403 "cancel" : self.keyRed,
1406 self["VKeyIcon"] = Pixmap()
1407 self["key_red"] = StaticText(_("Cancel"))
1408 self["key_green"] = StaticText(_("Save"))
1410 self.menuItemTitle = None
1411 self.menuItemUrl = None
1412 self.menuItemName = None
1414 self.menuEntryName = None
1415 self.menuEntryTitle = None
1416 self.menuEntryUrl = None
1418 self.makeConfigList()
1419 self.onLayoutFinish.append(self.layoutFinished)
1421 def layoutFinished(self):
1422 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1424 def selectedItem(self):
1425 currentPosition = self["config"].getCurrent()
1426 if self.mType == BookmarkEditWindow.CATEGORY:
1427 return (_("Name"), self.menuItemName)
1429 if currentPosition == self.menuEntryTitle:
1430 return (_("Title"), self.menuItemTitle)
1431 elif currentPosition == self.menuEntryUrl:
1432 return (_("Url"), self.menuItemUrl)
1435 def showMessageBox(self, text):
1436 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the") + " " + text + "."
1437 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1440 def showVKeyWindow(self, data=None):
1443 selected = self.selectedItem()
1444 if selected is not None:
1445 itemValue = selected[1].value
1446 if strIsEmpty(itemValue):
1448 itemTitle = selected[0]
1450 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1452 def cbVKeyWindow(self, data=None):
1453 if data is not None:
1454 selected = self.selectedItem()
1455 if selected is not None:
1456 selected[1].setValue(data)
1459 if self.mType == BookmarkEditWindow.CATEGORY:
1460 if self.mMode == _('Add'):
1461 categoryName = self.menuItemName.value
1462 if strIsEmpty(categoryName):
1463 return self.showMessageBox(_("Category Name"))
1464 self.mBookmarkManager.addCategory(categoryName)
1466 if strIsEmpty(self.menuItemName.value):
1467 return self.showMessageBox(_("Category Name"))
1468 self.mData.mName = self.menuItemName.value
1469 self.mBookmarkManager.updateCategory(self.mData)
1471 if self.mMode == _('Add'):
1472 bookmarkTitle = self.menuItemTitle.value
1473 bookmarkUrl = self.menuItemUrl.value
1474 if strIsEmpty(bookmarkTitle):
1475 self["config"].setCurrentIndex(0)
1476 return self.showMessageBox(_("Bookmark Title"))
1477 if strIsEmpty(bookmarkUrl):
1478 self["config"].setCurrentIndex(1)
1479 return self.showMessageBox(_("Bookmark URL"))
1480 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1482 if strIsEmpty(self.menuItemTitle.value):
1483 self["config"].setCurrentIndex(0)
1484 return self.showMessageBox(_("Bookmark Title"))
1485 if strIsEmpty(self.menuItemUrl.value):
1486 self["config"].setCurrentIndex(1)
1487 return self.showMessageBox(_("Bookmark URL"))
1488 self.mData.mTitle = self.menuItemTitle.value
1489 self.mData.mUrl = self.menuItemUrl.value
1490 self.mBookmarkManager.updateBookmark(self.mData)
1494 if not self.saveData():
1500 ConfigListScreen.keyLeft(self)
1502 ConfigListScreen.keyRight(self)
1503 def makeConfigList(self):
1506 if self.mType == BookmarkEditWindow.CATEGORY:
1507 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1509 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1511 self.menulist.append(self.menuEntryName)
1513 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1514 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1516 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1517 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1519 self.menulist.append(self.menuEntryTitle)
1520 self.menulist.append(self.menuEntryUrl)
1522 self["config"].list = self.menulist
1523 self["config"].l.setList(self.menulist)
1525 class OperaBrowserBookmarkWindow(Screen):
1527 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1528 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1530 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1531 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1533 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1534 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1535 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1536 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1538 <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" />
1539 <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" />
1540 <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" />
1541 <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" />
1545 def __init__(self, _session, _url=None, _title=None):
1547 self.mTitle = _title
1548 self.mBookmarkManager = BookmarkManager.getInstance()
1549 self.mSession = _session
1550 Screen.__init__(self, _session)
1551 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1553 "cancel": self.keyCancel,
1554 "red" : self.keyRed,
1555 "green" : self.keyGreen,
1556 "yellow": self.keyYellow,
1557 "blue" : self.keyBlue,
1558 "0" : self.keyNumber,
1561 self["key_red"] = StaticText(_("Exit"))
1562 self["key_green"] = StaticText(_("Add"))
1563 self["key_yellow"] = StaticText(_("Edit"))
1564 self["key_blue"] = StaticText(_("Delete"))
1565 self["key_0"] = StaticText(_("Set as Startpage"))
1567 self.mBookmarkList = self.setBookmarkList()
1568 self["bookmarklist"] = MenuList(self.mBookmarkList)
1570 self.onLayoutFinish.append(self.layoutFinished)
1572 def layoutFinished(self):
1573 self.setTitle(_('Bookmark'))
1575 def setBookmarkList(self):
1577 #self.mBookmarkManager.dump()
1578 cd = self.mBookmarkManager.getBookmarkRoot()
1579 for ck in cd.iterkeys():
1580 l.append(('# ' + cd[ck].mName, cd[ck]))
1581 bd = cd[ck].mBookmarks
1582 for bk in bd.iterkeys():
1583 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1585 def updateBookmarkList(self):
1586 self.mBookmarkList = self.setBookmarkList()
1587 self["bookmarklist"].setList(self.mBookmarkList)
1588 def cbEditWindow(self, ret=False):
1591 self.updateBookmarkList()
1592 def getParentCategory(self):
1593 idx = self["bookmarklist"].getSelectedIndex()
1596 data = self.mBookmarkList[idx][0].strip()
1598 return self.mBookmarkList[idx][1]
1602 def isCategoryItem(self):
1604 head = self["bookmarklist"].getCurrent()[0].strip()
1609 def keyNumber(self):
1610 data = self["bookmarklist"].getCurrent()[1]
1611 if strIsEmpty(data.mUrl):
1612 msg = _("Invalid URL. Please check again!!")
1613 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1615 def cbSetStartpage(ret=None):
1616 if ret is None: return
1618 data = self["bookmarklist"].getCurrent()[1]
1619 OperaBrowserSetting().setData(data.mUrl, data.mType)
1620 msg = _("Do you want to set selected url to the Startpage?")
1621 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1628 parent = self.getParentCategory()
1631 if strIsEmpty(self.mTitle):
1633 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1635 msg = _("Current page is already exist.")
1636 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1637 self.cbEditWindow(True)
1639 parent = self.getParentCategory()
1642 b = BookmarkData(0, '', '', parent.mId, 0)
1643 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1645 c = CategoryData(0, '')
1646 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1647 if strIsEmpty(self.mUrl):
1648 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1649 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1650 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1651 def keyYellow(self):
1652 data = self["bookmarklist"].getCurrent()[1]
1653 if self.isCategoryItem():
1654 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1655 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1657 def cbBlue(ret=None):
1659 data = self["bookmarklist"].getCurrent()[1]
1660 if self.isCategoryItem():
1661 self.mBookmarkManager.deleteCategory(data.mId)
1662 else: self.mBookmarkManager.deleteBookmark(data.mId)
1663 self.updateBookmarkList()
1664 if self.isCategoryItem():
1665 msg = _("Do you want to delete the category and the bookmarks?")
1666 else: msg = _("Do you want to delete the bookmark?")
1667 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1669 if self.isCategoryItem(): return
1671 data = self["bookmarklist"].getCurrent()[1]
1672 url = data.mUrl.strip()
1674 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1678 lang = language.getLanguage()
1679 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1680 url = '/usr/local/manual/ru_RU/main.html'
1681 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1682 url = '/usr/local/manual/de_DE/main.html'
1683 self.close((url, mode))
1686 def keyCancel(self):
1689 class BrowserHelpWindow(Screen, HelpableScreen):
1690 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1692 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1693 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1694 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1695 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1696 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1698 <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" />
1699 <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" />
1700 <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" />
1701 <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" />
1704 def __init__(self, session):
1705 Screen.__init__(self, session)
1706 HelpableScreen.__init__(self)
1708 self["key_red"] = StaticText(_("Exit"))
1709 self["key_green"] = StaticText(_("Global"))
1710 self["key_yellow"] = StaticText(_("Mouse"))
1711 self["key_blue"] = StaticText(_("Keyboard"))
1713 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1715 "cancel": self.keyRed,
1716 "red" : self.keyRed,
1717 "green" : self.keyGreen,
1718 "yellow": self.keyYellow,
1719 "blue" : self.keyBlue,
1722 self.showHelpTimer = eTimer()
1723 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1724 self.showHelpTimer.start(500)
1726 self.onLayoutFinish.append(self.layoutFinished)
1728 def layoutFinished(self):
1729 self.setTitle(_('Browser Help'))
1731 def cbShowHelpTimerClosed(self):
1732 self.showHelpTimer.stop()
1733 self.setHelpModeActions(self.MODE_GLOBAL)
1735 def setHelpModeActions(self, _mode=0):
1737 if _mode == self.MODE_GLOBAL:
1738 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1739 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1741 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1742 "menu" : (self.keyPass, _("Show the Menu window.")),
1744 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1745 "green" : (self.keyPass, _("Enter Key")),
1746 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1747 "blue" : (self.keyPass, _("Backspace Key")),
1749 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1750 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1753 elif _mode == self.MODE_MOUSE:
1754 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1755 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1756 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1757 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1758 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1760 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1761 "ok" : (self.keyPass, _("Left Mouse Button")),
1763 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1764 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1765 "nextService" : (self.keyPass, _("Left Key")),
1766 "prevService" : (self.keyPass, _("Right Key")),
1768 elif _mode == self.MODE_KEYBOARD:
1769 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1770 "up" : (self.keyPass, _("Up Key")),
1771 "down" : (self.keyPass, _("Down Key")),
1772 "left" : (self.keyPass, _("Left Key")),
1773 "right" : (self.keyPass, _("Right Key")),
1775 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1776 "ok" : (self.keyPass, _("Enter Key")),
1778 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1779 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1780 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1781 "nextService" : (self.keyPass, _("Go to previous page.")),
1782 "prevService" : (self.keyPass, _("Go to next page.")),
1794 self.setHelpModeActions(self.MODE_GLOBAL)
1795 def keyYellow(self):
1796 self.setHelpModeActions(self.MODE_MOUSE)
1798 self.setHelpModeActions(self.MODE_KEYBOARD)
1800 class OperaBrowser(Screen):
1801 MENUBAR_ITEM_WIDTH = 150
1802 MENUBAR_ITEM_HEIGHT = 30
1803 SUBMENULIST_WIDTH = 200
1804 SUBMENULIST_HEIGHT = 25
1805 SUBMENULIST_NEXT = 2
1807 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1808 # menulist->size->x : SUBMENULIST_WIDTH
1809 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1810 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1811 # submenulist->size->x : SUBMENULIST_WIDTH
1813 size = getDesktop(0).size()
1814 WIDTH = int(size.width())
1815 HEIGHT = int(size.height())
1817 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1818 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1819 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1820 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1821 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1822 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1823 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1824 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1826 """ % { 'width' :WIDTH,
1828 'bottom_pos_y' :HEIGHT-80,
1829 'bottom_size_x' :WIDTH }
1833 def __init__(self, session, url=None, isWebAppMode=False):
1834 Screen.__init__(self, session)
1835 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1836 "cancel" : self.keyCancel
1838 ,"left" : self.keyLeft
1839 ,"right" : self.keyRight
1841 ,"down" : self.keyDown
1842 ,"menu" : self.keyMenu
1845 self.UpdateLanguageCB()
1847 self._terminatedBrowser = True
1848 self._enableKeyEvent = True
1849 self._currentPageUrl = None
1850 self._currentPageTitle = None
1851 self.menubarCurrentIndex = 0
1852 self.lvMenuItems = []
1853 self.lvSubMenuItems = []
1855 self["topArea"] = Label()
1856 self["bottomArea"] = Label()
1858 self["menuitemFile"] = MultiColorLabel()# modify menu
1859 self["menuitemTool"] = MultiColorLabel()
1860 self["menuitemHelp"] = MultiColorLabel()
1862 self["menulist"] = MenuList(self.setListOnView())
1863 self["submenulist"] = MenuList(self.setSubListOnView())
1865 self.toggleMainScreenFlag = True
1866 self.toggleListViewFlag = False
1867 self.toggleSubListViewFlag = False
1868 self.currentListView = self["menulist"]
1870 self.onLayoutFinish.append(self.layoutFinished)
1872 self._onCloseTimer = eTimer()
1873 self._onCloseTimer.callback.append(self._cb_onClose)
1876 self.paramIsWebAppMode = isWebAppMode
1877 language.addCallback(self.UpdateLanguageCB)
1879 def UpdateLanguageCB(self):
1881 self.MENUITEMS_LIST = [
1882 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1883 [(_('Bookmark'), None), (_('Preference'), None)],
1884 [(_('About'), None), (_('Help'), None)]]
1885 self.COMMAND_MAP = {}
1886 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1887 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1888 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1889 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1890 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1891 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1892 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1893 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1894 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1896 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1897 rcmouse_path = "/proc/stb/fp/mouse"
1898 if os.path.exists(rcmouse_path):
1899 os.system("echo %d > %s" % (mode, rcmouse_path))
1901 def layoutFinished(self):
1902 self["menuitemFile"].setText(_("File"))# modify menu
1903 self["menuitemTool"].setText(_("Tools"))
1904 self["menuitemHelp"].setText(_("Help"))
1906 self["menulist"].hide()
1907 self["submenulist"].hide()
1909 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1910 self.setTitle(_("BrowserMain"))
1911 self.selectMenuitem()
1913 if self.paramUrl is not None:
1915 if self.paramIsWebAppMode:
1916 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1917 else: self.cbUrlText(data=self.paramUrl, mode=1)
1919 def selectMenuitem(self):
1920 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1921 self["menuitemFile"].setForegroundColorNum(0)
1922 self["menuitemTool"].setForegroundColorNum(0)
1923 self["menuitemHelp"].setForegroundColorNum(0)
1924 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1926 def popupCloseAll(self):
1932 def setListOnView(self):
1933 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1934 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1935 l = [(_('Return'), None)]
1936 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1937 return self.lvMenuItems
1939 def setSubListOnView(self):
1940 self.lvSubMenuItems = []
1941 xl = self["menulist"].getCurrent()[1]
1942 if xl is None: return []
1944 self.lvSubMenuItems.append((x,None))
1945 return self.lvSubMenuItems
1947 def toggleMainScreen(self):
1948 if not self.toggleMainScreenFlag:
1951 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1953 def toggleListView(self):
1954 if not self.toggleListViewFlag:
1955 self["menulist"].show()
1956 else: self["menulist"].hide()
1957 self.toggleListViewFlag = not self.toggleListViewFlag
1959 def toggleSubListView(self):
1960 if not self.toggleSubListViewFlag:
1961 self["submenulist"].show()
1962 else: self["submenulist"].hide()
1963 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1965 def setCurrentListView(self, listViewIdx):
1966 if listViewIdx == 0:
1967 self.currentListView = None
1968 elif listViewIdx == 1:
1969 self.currentListView = self["menulist"]
1970 elif listViewIdx == 2:
1971 self.currentListView = self["submenulist"]
1973 def _cb_onClose(self):
1974 self._onCloseTimer.stop()
1975 command_server = getCommandServer()
1977 if self._on_close_window in command_server.onHbbTVCloseCB:
1978 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1979 except Exception, ErrMsg: pass
1981 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1982 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1983 except Exception, ErrMsg: pass
1984 self._on_setPageTitle(_('Opera Browser'))
1985 self.enableRCMouse(False)
1986 self.toggleMainScreen()
1988 fbClass.getInstance().unlock()
1989 eRCInput.getInstance().unlock()
1990 self._terminatedBrowser = True
1991 self._enableKeyEvent = True
1992 #if not self.toggleListViewFlag:
1995 self._currentPageUrl = ''
1996 if self.paramUrl is not None:
2002 def _on_setPageTitle(self, title=None):
2003 print "Title :",title
2006 self.setTitle(title)
2008 def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
2010 if not _g_helper._is_browser_running():
2012 print "Inputed Url :", data, mode
2013 if strIsEmpty(data):
2016 command_server = getCommandServer()
2017 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
2018 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
2019 if self._on_close_window not in command_server.onHbbTVCloseCB:
2020 command_server.onHbbTVCloseCB.append(self._on_close_window)
2021 self.toggleMainScreen()
2022 self.enableRCMouse(True)
2024 fbClass.getInstance().lock()
2025 eRCInput.getInstance().lock()
2027 #setResolution(1280, 720)
2029 command_util = getCommandUtil()
2030 command_util.sendCommand(opcode, data, mode)
2031 self._terminatedBrowser = False
2032 self._enableKeyEvent = False
2035 __gval__.hbbtv_handelr._soft_volume = -1
2037 def _on_close_window(self):
2038 self._onCloseTimer.start(1000)
2040 def _cb_bookmarkWindowClosed(self, data=None):
2045 if not _g_helper._is_browser_running():
2046 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2047 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2049 self.cbUrlText(url, mode)
2051 def _cmd_on_OpenUrl(self):
2053 if not _g_helper._is_browser_running():
2054 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2055 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2057 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2058 def _cmd_on_About(self):
2059 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2060 def _cmd_on_Exit(self):
2062 def _cb_cmdOnStartSTop(self):
2064 def _cmd_on_StartStop(self):
2066 if _g_helper is None:
2068 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2070 def _cmd_on_Bookmark(self):
2071 url = self._currentPageUrl
2074 title = self._currentPageTitle
2077 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2078 def _cmd_on_Preference(self):
2079 url = self._currentPageUrl
2082 self.session.open(OperaBrowserPreferenceWindow, url)
2083 def _cmd_on_OpenStartpage(self):
2085 if not _g_helper._is_browser_running():
2086 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2087 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2090 start = 'http://vuplus.com'
2092 d = OperaBrowserSetting().getData()
2096 self.cbUrlText(start, mode)
2097 def _cmd_on_ReturnToBrowser(self):
2100 def _cmd_on_Help(self):
2101 self.session.open(BrowserHelpWindow)
2103 def doCommand(self, command):
2105 self.COMMAND_MAP[command]()
2106 except Exception, ErrMsg: print ErrMsg
2109 if not self.toggleMainScreenFlag:
2112 if not self.toggleListViewFlag:
2115 if self.currentListView.getCurrent()[1] is None:
2116 self.doCommand(self.currentListView.getCurrent()[0])
2117 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2121 def updateSelectedMenuitem(self, status):
2122 if self.menubarCurrentIndex == 0 and status < 0:
2123 self.menubarCurrentIndex = 2 # modify menu
2124 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2125 self.menubarCurrentIndex = 0
2126 else: self.menubarCurrentIndex += status
2127 self.selectMenuitem()
2130 if not self.toggleMainScreenFlag:
2132 if not self.toggleListViewFlag:
2133 self.updateSelectedMenuitem(-1)
2135 if self.toggleSubListViewFlag:
2136 self.setCurrentListView(1)
2137 self.toggleSubListView()
2139 #if self.currentListView.getSelectedIndex():
2140 self.currentListView.pageUp()
2146 if not self.toggleMainScreenFlag:
2148 if not self.toggleListViewFlag:
2149 self.updateSelectedMenuitem(1)
2151 if self.currentListView is None:
2153 if self.currentListView.getCurrent()[1] is not None:
2154 parentSelectedIndex = self.currentListView.getSelectedIndex()
2155 self.setCurrentListView(2)
2156 self.currentListView.setList(self.setSubListOnView())
2157 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2158 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))
2159 self.toggleSubListView()
2161 self.currentListView.pageUp()
2167 if not self.toggleMainScreenFlag:
2169 if self.currentListView is None:
2171 if not self.toggleListViewFlag:
2172 self.currentListView.setList(self.setListOnView())
2173 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2174 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2175 self.toggleListView()
2177 self.currentListView.down()
2180 if not self.toggleMainScreenFlag:
2182 if self.currentListView is None:
2184 if self.currentListView == self["menulist"]:
2185 if self.currentListView.getSelectedIndex() == 0:
2186 self.toggleListView()
2188 self.currentListView.up()
2190 def keyCancel(self):
2191 if not self._terminatedBrowser:
2192 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2193 fbClass.getInstance().lock()
2194 eRCInput.getInstance().lock()
2195 #setResolution(1280, 720)
2196 if self.toggleListViewFlag:
2197 self.toggleMainScreen()
2198 self._currentPageUrl = None
2199 self._currentPageTitle = None
2200 command_util = getCommandUtil()
2201 command_util.sendCommand('OP_BROWSER_MENU_RES')
2206 self.toggleMainScreen()
2208 def setCurrentPageUrl(self, url, title=None):
2209 self._currentPageUrl = url
2212 if idx > 10: idx = 10
2214 self._currentPageTitle = title
2215 print self._currentPageUrl
2216 self.toggleMainScreen()
2220 def hideSubmenu(self):
2221 self.currentListView.pageUp()
2224 config.plugins.youtubetv = ConfigSubsection()
2225 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2226 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2227 class YoutubeTVWindow(Screen, HelpableScreen):
2229 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2230 <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2231 <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2232 <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2233 <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2234 <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2235 <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" />
2236 <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" />
2239 def __init__(self, session):
2240 Screen.__init__(self, session)
2241 HelpableScreen.__init__(self)
2243 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2244 "cancel": self.keyCancel,
2245 "red" : self.keyCancel,
2246 "green" : self.keyGreen,
2247 "yellow": self.keyYellow,
2250 self["key_green"] = StaticText(_("Start"))
2251 self["key_yellow"] = StaticText(_("Help"))
2253 self["infomation"] = Label()
2254 self["startdesc"] = Label()
2255 self["helpdesc"] = Label()
2257 self.onLayoutFinish.append(self.layoutFinished)
2259 def layoutFinished(self):
2260 self.setTitle(_('Start YouTube TV'))
2261 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2262 self["startdesc" ].setText(_("* Start YouTube TV"))
2263 self["helpdesc" ].setText(_("* RC Help"))
2265 def setHelpModeActions(self):
2267 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2268 "ok" : (self.keyPass, _("Play ther selected the video")),
2269 "cancel": (self.keyPass, _("Exit the YouTube TV")),
2271 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2272 "pageUp" : (self.keyPass, _("Move up")),
2273 "pageDown" : (self.keyPass, _("Move down")),
2274 "prevEvent" : (self.keyPass, _("Move left")),
2275 "nextEvent" : (self.keyPass, _("Move right")),
2277 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2278 "info" : (self.keyPass, _("Search a video")),
2279 "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2280 "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2282 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2283 "play" : (self.keyPass, _("Play current video")),
2284 "pause" : (self.keyPass, _("Pause current video")),
2285 "stop" : (self.keyPass, _("Stop current video")),
2287 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2288 "red" : (self.keyPass, _("Back")),
2294 def keyCancel(self):
2295 config.plugins.youtubetv.showhelp.cancel()
2298 config.plugins.youtubetv.showhelp.save()
2299 config.plugins.youtubetv.save()
2300 config.plugins.save()
2302 def keyYellow(self):
2303 self.setHelpModeActions()
2305 if config.plugins.youtubetv.showhelp.value == True :
2306 config.plugins.youtubetv.showhelp.setValue(False)
2307 else: config.plugins.youtubetv.showhelp.setValue(True)
2309 class YoutubeTVSettings(ConfigListScreen, Screen):
2311 <screen position="center,center" size="600,140" title="YouTube TV Settings">
2312 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2314 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2315 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2317 <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" />
2318 <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" />
2321 def __init__(self, session):
2322 self.session = session
2323 Screen.__init__(self, session)
2326 ConfigListScreen.__init__(self, self.menulist)
2328 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2329 "ok" : self.keyGreen,
2330 "green" : self.keyGreen,
2331 "red" : self.keyRed,
2332 "cancel" : self.keyRed,
2335 self["key_red"] = StaticText(_("Cancel"))
2336 self["key_green"] = StaticText(_("Save"))
2338 self.makeConfigList()
2339 self.onLayoutFinish.append(self.layoutFinished)
2341 def layoutFinished(self):
2342 self.setTitle(_('YouTube TV Settings'))
2345 config.plugins.youtubetv.showhelp.save()
2346 config.plugins.youtubetv.uri.save()
2347 config.plugins.youtubetv.save()
2348 config.plugins.save()
2351 config.plugins.youtubetv.showhelp.cancel()
2352 config.plugins.youtubetv.uri.cancel()
2356 ConfigListScreen.keyLeft(self)
2359 ConfigListScreen.keyRight(self)
2361 def makeConfigList(self):
2363 entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2364 entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Starter again"), config.plugins.youtubetv.showhelp)
2365 self.menulist.append(entryUri)
2366 self.menulist.append(entryShowHelp)
2368 self["config"].list = self.menulist
2369 self["config"].l.setList(self.menulist)
2371 def auto_start_main(reason, **kwargs):
2373 command_server = getCommandServer()
2374 command_server.stop()
2376 from Screens.HelpMenu import HelpableScreen
2377 def session_start_main(session, reason, **kwargs):
2378 fbClass.getInstance().unlock()
2379 eRCInput.getInstance().unlock()
2381 from enigma import getDesktop
2382 desktopSize = getDesktop(0).size()
2383 setDefaultResolution(desktopSize.width(), desktopSize.height())
2386 _g_helper = session.open(HbbTVHelper)
2388 HelpableScreen.__init__ = HelpableScreen__init__
2389 HelpableScreen.session = session
2391 def HelpableScreen__init__(self):
2392 if isinstance(self, HelpableScreen):
2393 HelpableScreen.showManual = showManual
2395 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2396 "help_b" : self.showHelp,
2397 "help_l" : self.showManual,
2400 _g_clearBrowserDataTimer = eTimer()
2401 def showManual(self):
2402 if not os.path.exists('/usr/local/manual'):
2405 url = 'file:///usr/local/manual/main.html'
2406 lang = language.getLanguage()
2407 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2408 url = 'file:///usr/local/manual/ru_RU/main.html'
2409 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2410 url = 'file:///usr/local/manual/de_DE/main.html'
2413 _g_clearBrowserDataTimer.stop()
2414 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2416 setPluginBrowser(None)
2418 def clearBrowserData():
2419 _g_clearBrowserDataTimer.callback.append(_do_clean)
2420 _g_clearBrowserDataTimer.start(50)
2421 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2423 _g_backupSession = None
2424 def showYoutubeTV(session, **kwargs):
2426 _g_clearBrowserDataTimer.stop()
2427 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2429 setPluginBrowser(None)
2430 global _g_backupSession
2432 service = getBeforeService()
2433 if service is not None:
2434 _g_backupSession.nav.playService(eServiceReference(service))
2435 _g_backupSession = None
2436 def clearBrowserData():
2437 _g_clearBrowserDataTimer.callback.append(_do_clean)
2438 _g_clearBrowserDataTimer.start(50)
2439 def cbYoutubeTVClose(ret):
2441 global _g_backupSession
2442 _g_backupSession = session
2443 service = session.nav.getCurrentlyPlayingServiceReference()
2444 if service is not None:
2445 setBeforeService(service.toString())
2446 session.nav.stopService()
2447 else: setBeforeService(service)
2448 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2449 if config.plugins.youtubetv.showhelp.value == True:
2450 cbYoutubeTVClose(True)
2451 else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2453 def youtube_setting_main(session, **kwargs):
2454 session.open(YoutubeTVSettings)
2456 def start_menu_main(menuid, **kwargs):
2457 if menuid == "mainmenu":
2458 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2461 def plugin_start_main(session, **kwargs):
2462 #session.open(OperaBrowser)
2464 _g_clearBrowserDataTimer.stop()
2465 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2467 setPluginBrowser(None)
2468 def clearBrowserData():
2469 _g_clearBrowserDataTimer.callback.append(_do_clean)
2470 _g_clearBrowserDataTimer.start(50)
2471 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2473 def plugin_extension_start_application(session, **kwargs):
2475 if _g_helper is None:
2477 _g_helper.showApplicationSelectionBox()
2479 def plugin_extension_browser_config(session, **kwargs):
2481 if _g_helper is None:
2483 _g_helper.showBrowserConfigBox()
2485 def Plugins(path, **kwargs):
2487 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2488 l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2489 l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2490 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2491 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2492 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2493 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))