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
486 self._videobackend_activate = False
488 def _handle_dump(self, handle, opcode, data=None):
492 print " - opcode : ", self.opcode.what(opcode)
494 print " - data : ", data
496 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
497 opcode, params, reserved = None, None, 0
498 self._on_close_cb = onCloseCB
499 self._on_set_title_cb = onSetPageTitleCB
501 datas = self.doUnpack(data)
502 except Exception, ErrMsg:
503 print "Unpacking packet ERR :", ErrMsg
504 params = 'fail to unpack packet!!'
505 opcode = self.opcode.get("OP_UNKNOWN")
506 return self.doPack(opcode, params)
510 self.opcode.what(opcode)
513 #print self.handle_map[opcode]
514 (reserved, params) = self.handle_map[opcode](opcode, params)
515 except Exception, ErrMsg:
516 print "Handling packet ERR :", ErrMsg
517 params = 'fail to handle packet!!'
518 opcode = self.opcode.get("OP_UNKNOWN")
519 return self.doPack(opcode, params)
520 self._on_close_cb = None
521 self._on_set_title_cb = None
522 return self.doPack(opcode, params, reserved)
524 def _cb_handleVideobackendEnable(self, opcode, data):
525 self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
526 service = self._session.nav.getCurrentlyPlayingServiceReference()
527 setBeforeService(service)
528 self._session.nav.stopService()
529 self._videobackend_activate = True
532 def _cb_handleVideobackendDisable(self, opcode, data):
533 self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
534 before_service = getBeforeService()
535 if before_service is not None:
536 self._session.nav.playService(before_service)
537 self._videobackend_activate = False
540 def _cb_handleHbbTVChangeChannel(self, opcode, data):
541 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
543 if _g_helper is None:
545 dataItems = data.split(":")
548 if not _g_helper.doChangeChannel(sid, tsid):
552 def _cb_handleBrowserMenuReq(self, opcode, data):
553 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
555 fbClass.getInstance().unlock()
556 eRCInput.getInstance().unlock()
557 browser = getPluginBrowser()
558 if browser is not None:
559 browser.setCurrentPageUrl(data, self._curren_title)
562 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
563 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
564 def _cb_PasteRefocusVirtualKeyboard():
565 self._timer_paste_vkbd.stop()
566 command_util = getCommandUtil()
567 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
569 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
571 def _cb_PasteKeyVirtualKeyboard():
572 self._timer_paste_vkbd.stop()
573 command_util = getCommandUtil()
574 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
576 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
578 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
579 self._timer_paste_vkbd.start(100)
580 def _cb_PasteMouseVirtualKeyboard():
581 self._timer_paste_vkbd.stop()
582 command_util = getCommandUtil()
583 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
585 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
587 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
589 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
590 #self._timer_paste_vkbd.start(1000)
591 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
592 self._timer_paste_vkbd.start(50)
595 def _cb_virtualKeyboardClosed(self, data=None):
596 fbClass.getInstance().lock()
597 eRCInput.getInstance().lock()
598 #setResolution(1280, 720)
599 command_util = getCommandUtil()
600 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
602 def _cb_handleShowVirtualKeyboard(self, opcode, data):
603 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
605 fbClass.getInstance().unlock()
606 eRCInput.getInstance().unlock()
607 if data == 0 or strIsEmpty(data):
609 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
612 def _cb_handleVODSeekCtrl(self, opcode, data):
613 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
614 headLen = struct.calcsize('!I')
615 unpackedData = struct.unpack('!I', data[:headLen])
616 seekTime = unpackedData[0]
617 service = self._session.nav.getCurrentService()
618 seekable = service.seek()
619 if seekable is None or not seekable.isCurrentlySeekable():
620 raise Exception("This stream is not support manual seek.")
622 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
625 def _cb_handleHbbTVRetryOpen(self, opcode, data):
626 def _cb_HbbTVRetryOpenURL():
627 self._timer_retry_open.stop()
628 if self._retry_open_url is not None:
629 command_util = getCommandUtil()
630 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
631 self._retry_open_url = None
633 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
635 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
636 headLen = struct.calcsize('!I')
637 unpackedData = struct.unpack('!I', data[:headLen])
638 delayTime = unpackedData[0]
639 restartUrl = data[headLen:]
641 self._retry_open_url = restartUrl.strip()
642 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
643 self._timer_retry_open.start(delayTime*1000)
646 def _cb_handleSystemNotufyMyPID(self, opcode, data):
647 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
650 def _cb_handleSystemOutOfMemory(self, opcode, data):
651 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
655 def _cb_handleVODSpeedCtrl(self, opcode, data):
656 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
657 headLen = struct.calcsize('!I')
658 unpackedData = struct.unpack('!I', data[:headLen])
659 playSpeed = unpackedData[0]
660 service = self._session.nav.getCurrentService()
661 pauseable = service.pause()
664 if pauseable.setFastForward(playSpeed) == -1:
665 pauseable.setFastForward(1)
666 raise Exception("This stream is not support trick play.")
669 def SetVolume(self, volume):
670 if self._max_volume < 0:
671 self._max_volume = VolumeControl.instance.volctrl.getVolume()
673 self._max_volume += volume
674 if self._max_volume > 100:
675 self._max_volume = 100
676 elif self._max_volume < 0:
679 if self._soft_volume > 0:
680 v = int((self._max_volume * self._soft_volume) / 100)
681 VolumeControl.instance.volctrl.setVolume(v, v)
682 else: VolumeControl.instance.volctrl.setVolume(self._max_volume, self._max_volume)
684 def _cb_handleDVBAppVolUp(self, opcode, data):
685 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
689 def _cb_handleDVBAppVolDown(self, opcode, data):
690 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
694 def _cb_handleDVBAppSetVol(self, opcode, data):
695 self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data)
696 if self._max_volume < 0:
697 self._max_volume = VolumeControl.instance.volctrl.getVolume()
698 self._soft_volume = int(data)
701 if self._soft_volume > 0 and self._max_volume > 0:
702 v = int((self._max_volume * self._soft_volume) / 100)
703 VolumeControl.instance.volctrl.setVolume(v, v)
706 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
707 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
708 (sid, onid, tsid, name, orgid) = getChannelInfos()
710 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
712 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
713 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
714 (sid, onid, tsid, name, orgid) = getChannelInfos()
716 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
718 def _cb_handleGetChannelInfoList(self, opcode, data):
719 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
720 (sid, onid, tsid, name, orgid) = getChannelInfos()
722 channel_list_size = 1
723 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
725 def _cb_handleSetPageTitle(self, opcode, data):
726 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
727 if data.startswith('file://') or data.startswith('http://'):
729 if self._on_set_title_cb is not None:
730 for x in self._on_set_title_cb:
733 self._curren_title = data
734 except Exception, ErrMsg:
735 if x in self._on_set_title_cb:
736 self._on_set_title_cb.remove(x)
739 def _cb_handleHbbTVAbortSig(self, opcode, data):
740 self._cb_handleCloseHbbTVBrowser(opcode, data)
742 return (0, struct.pack('!II', __gval__.resX, __gval__.resY));
744 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
745 self._timer_retry_open.stop()
747 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
749 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
751 if self._on_close_cb:
752 for x in self._on_close_cb:
755 except Exception, ErrMsg:
756 if x in self._on_close_cb:
757 self._on_close_cb.remove(x)
759 command_util = getCommandUtil()
760 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
761 if self._videobackend_activate == False:
762 before_service = getBeforeService()
763 if before_service is not None:
764 self._session.nav.playService(before_service)
770 def _cb_handleVODPlayerURI(self, opcode, data):
772 hl = struct.calcsize('!II')
773 datas = struct.unpack('!II', data[:hl])
775 vodUri = data[hl:hl+uriLength]
776 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
777 self._vod_uri = vodUri
780 def doStop(self, restoreBeforeService=True, needStop=True):
782 self._session.nav.stopService()
783 if self._vod_service is not None and restoreBeforeService:
784 before_service = getBeforeService()
785 self._session.nav.playService(before_service)
787 self._vod_service = None
792 def doRetryOpen(self, url):
796 self._vod_service = None
798 #print "Try to open vod [%d] : %s" % (ii, url)
799 print "Try to open vod"
800 self._vod_service = eServiceReference(4097, 0, url)
801 self._session.nav.playService(self._vod_service)
802 if self._vod_service is not None:
804 except Exception, ErrMsg:
805 print "OpenVOD ERR :", ErrMsg
809 def _cb_handleVODPlayerPlay(self, opcode, data):
810 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
811 self.doStop(restoreBeforeService=False)
812 if self.doRetryOpen(url=self._vod_uri) == False:
816 def _cb_handleVODPlayerStop(self, opcode, data):
817 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
821 def _cb_handleVODPlayerPlayPause(self, opcode, data):
822 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
823 service = self._session.nav.getCurrentService()
826 servicePause = service.pause()
828 servicePause.unpause()
829 elif pauseFlag == 'P':
831 except Exception, ErrMsg:
832 print "onPause ERR :", ErrMsg
835 from libshm import SimpleSharedMemory
837 class HbbTVWindow(Screen, InfoBarNotifications):
839 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
842 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
843 self._session = session
844 setResolution(1280, 720)
845 fbClass.getInstance().lock()
846 eRCInput.getInstance().lock()
848 Screen.__init__(self, session)
849 InfoBarNotifications.__init__(self)
850 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
851 iPlayableService.evStart: self._serviceStarted,
852 iPlayableService.evEOF: self._serviceEOF,
856 self._use_ait = useAIT
857 self._profile = profile
858 self._cb_closed_func = cbf
859 self.onLayoutFinish.append(self._layoutFinished)
861 command_server = getCommandServer()
862 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
863 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
865 if self._cb_close_window not in command_server.onHbbTVCloseCB:
866 command_server.onHbbTVCloseCB.append(self._cb_close_window)
868 self._closeTimer = eTimer()
869 self._closeTimer.callback.append(self._do_close)
871 self._currentServicePositionTimer = eTimer()
872 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
879 def getVodPlayTime(self):
881 service = self._session.nav.getCurrentService()
882 seek = service and service.seek()
884 p = seek.getPlayPosition()
885 if(not l[0] and not p[0]):
891 def _cb_currentServicePosition(self):
892 def getTimeString(t):
893 t = time.localtime(t/90000)
894 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
895 position,length = 0,0
897 (position,length) = self.getVodPlayTime()
898 self._vod_length = length
899 if position == -1 and length == -1:
900 raise Exception("Can't get play status")
901 #print position, "/", length, " - ", getTimeString(position), "/", getTimeString(length)
902 self._ssm.setStatus(position, length, 1)
903 except Exception, ErrMsg:
907 def _serviceStarted(self):
909 self._ssm.setStatus(0, 0, 0)
910 self._currentServicePositionTimer.start(1000)
911 except Exception, ErrMsg:
914 def _serviceEOF(self):
915 (position,length) = self.getVodPlayTime()
916 self._ssm.setStatus(length, length, 1)
918 self._currentServicePositionTimer.stop()
920 def _layoutFinished(self):
922 __gval__.hbbtv_handelr._soft_volume = -1
923 self.setTitle(_('HbbTV Plugin'))
924 command_util = getCommandUtil()
925 profile = self._profile
926 (sid, onid, tsid, name, orgid) = getChannelInfos()
927 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
929 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
931 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
933 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
935 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
937 def _cb_close_window(self):
938 self._closeTimer.start(1000)
941 self._closeTimer.stop()
942 command_server = getCommandServer()
944 if self._cb_set_page_title in command_server.onSetPageTitleCB:
945 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
946 except Exception, ErrMsg: pass
948 if self._cb_close_window in command_server.onHbbTVCloseCB:
949 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
950 except Exception, ErrMsg: pass
952 if self._cb_closed_func is not None:
953 self._cb_closed_func()
956 fbClass.getInstance().unlock()
957 eRCInput.getInstance().unlock()
960 def _cb_set_page_title(self, title=None):
961 print "page title :",title
966 class HbbTVHelper(Screen, InfoBarNotifications):
967 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
968 def __init__(self, session):
970 __gval__.hbbtv_handelr = HandlerHbbTV(session)
971 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
973 Screen.__init__(self, session)
974 InfoBarNotifications.__init__(self)
976 self._session = session
978 self._restart_opera()
980 self._timer_infobar = eTimer()
981 self._timer_infobar.callback.append(self._cb_registrate_infobar)
982 self._timer_infobar.start(1000)
984 self._excuted_browser = False
987 __gval__.command_util = BrowserCommandUtil()
991 _g_ssm_ = SimpleSharedMemory()
994 self._callbackStartStop = None
996 self.__et = ServiceEventTracker(screen=self, eventmap={
997 iPlayableService.evHBBTVInfo: self._cb_detectedAIT,
998 iPlayableService.evUpdatedInfo: self._cb_updateInfo
1000 self._applicationList = None
1003 from Screens.InfoBarGenerics import gHbbtvApplication
1004 self.mVuplusBox = gHbbtvApplication.getUseAit()
1006 self.mVuplusBox = False
1008 def _cb_detectedAIT(self):
1009 name = self._cb_ready_for_ait()
1010 if name is not None and self.mVuplusBox:
1011 from Screens.InfoBarGenerics import gHbbtvApplication
1012 gHbbtvApplication.setApplicationName(str(name))
1014 def _cb_updateInfo(self):
1015 if not self._excuted_browser:
1016 command_util = getCommandUtil()
1017 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1019 from Screens.InfoBarGenerics import gHbbtvApplication
1020 gHbbtvApplication.setApplicationName("")
1021 #self._applicationList = None
1023 def _cb_registrate_infobar(self):
1024 if InfoBar.instance:
1025 self._timer_infobar.stop()
1026 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
1027 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
1029 def _cb_ready_for_ait(self):
1030 setChannelInfo(None, None, None, None, None)
1032 service = self._session.nav.getCurrentService()
1033 info = service and service.info()
1034 if info is not None:
1035 sid = info.getInfo(iServiceInformation.sSID)
1036 onid = info.getInfo(iServiceInformation.sONID)
1037 tsid = info.getInfo(iServiceInformation.sTSID)
1038 name = info.getName()
1042 pmtid = info.getInfo(iServiceInformation.sPMTPID)
1043 demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
1045 from aitreader import eAITSectionReader
1046 reader = eAITSectionReader(demux, pmtid, sid)
1047 if reader.doOpen(info, self.mVuplusBox):
1048 reader.doParseApplications()
1050 else: print "no data!!"
1053 self._applicationList = reader.getApplicationList()
1054 if len(self._applicationList) > 0:
1055 orgid = int(self._applicationList[0]["orgid"])
1056 setChannelInfo(sid, onid, tsid, name, orgid)
1057 return self._applicationList[0]["name"]
1061 def _cb_hbbtv_activated(self, title=None, url=None):
1062 if not self._is_browser_running():
1063 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1064 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1066 service = self._session.nav.getCurrentlyPlayingServiceReference()
1067 setBeforeService(service)
1068 self._start_hbbtv_application(title, url)
1070 def _start_hbbtv_application(self, title, url):
1072 tmp_url = self.getStartHbbTVUrl()
1076 print "can't get url of hbbtv!!"
1078 print "success to get url of hbbtv!! >>", url
1079 if self._excuted_browser:
1080 print "already excuted opera browser!!"
1084 self._restart_opera()
1086 setNeedRestart(False)
1088 for x in self._applicationList:
1089 control_code = int(x["control"])
1091 if tmp_url == url and control_code == 1:
1093 self._excuted_browser = True
1094 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1096 def _cb_closed_browser(self):
1097 self._excuted_browser = False
1099 def _start_opera(self):
1100 if not self._is_browser_running():
1101 global HBBTVAPP_PATH
1103 start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
1104 os.system(start_command)
1107 def _stop_opera(self):
1108 global HBBTVAPP_PATH
1109 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1113 def _restart_opera(self):
1114 global HBBTVAPP_PATH
1116 try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
1120 def getStartHbbTVUrl(self):
1121 url, self._profile = None, 0
1122 if self._applicationList is not None:
1123 for u in self._applicationList:
1124 if u["control"] in (1, -1):
1126 self._profile = u["profile"]
1128 service = self._session.nav.getCurrentService()
1129 info = service and service.info()
1131 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1134 def showApplicationSelectionBox(self):
1137 if self.getStartHbbTVUrl():
1138 for x in self._applicationList:
1139 applications.append((x["name"], x))
1140 else: applications.append((_("No detected HbbTV applications."), None))
1141 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1143 def _application_selected(self, selected):
1146 if selected[1] is None: return
1147 self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
1148 except Exception, ErrMsg: print ErrMsg
1150 def showBrowserConfigBox(self, callback=None):
1151 start_stop_mode = []
1152 self._callbackStartStop = callback
1153 if self._is_browser_running():
1154 start_stop_mode.append((_('Stop'),'Stop'))
1155 else: start_stop_mode.append((_('Start'),'Start'))
1156 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1158 def _browser_config_selected(self, selected):
1159 if selected is None:
1161 if self._callbackStartStop is not None:
1162 self._callbackStartStop()
1166 if not self._is_browser_running():
1168 elif mode == 'Stop':
1170 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1172 def _is_browser_running(self):
1174 global HBBTVAPP_PATH
1175 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1176 return ret.strip() != "0"
1177 except Exception, ErrMsg:
1178 print "Check Browser Running ERR :", ErrMsg
1181 def doChangeChannel(self, _sid, _tsid):
1182 root = eServiceReference(service_types_tv)
1185 serviceList = eServiceCenter.getInstance().list(root)
1186 if serviceList is None:
1189 service = serviceList.getNext()
1190 if service is None or not service.valid():
1193 #1:0:19:2840:3FB:1:C00000:0:0:0:
1194 serviceRef = service.toString()
1195 if strIsEmpty(serviceRef):
1197 serviceRefItems = serviceRef.split(":")
1198 if len(serviceRefItems) < 5:
1201 sid = serviceRefItems[3]
1202 tsid = serviceRefItems[4]
1203 if sid == _sid and tsid == _tsid:
1204 self._session.nav.playService(eServiceReference(serviceRef))
1205 service = self._session.nav.getCurrentlyPlayingServiceReference()
1206 setBeforeService(service)
1210 class OperaBrowserSetting:
1212 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1218 f = open(self._settingFileName)
1219 for line in f.readlines():
1220 if line.startswith('start='):
1221 tmp = line[6:len(line)-1].split()
1222 self._start = tmp[0]
1224 self._type = int(tmp[1])
1225 else: self._type = 0
1226 elif line.startswith('keymap='):
1227 self._keymap = line[7:len(line)-1]
1231 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1232 tmpstr.append('keymap=%s\n' % (self._keymap))
1233 f = open(self._settingFileName, 'w')
1234 f.writelines(tmpstr)
1236 def setData(self, start, types=0, keymap="us-rc"):
1239 self._keymap = keymap
1243 'start':self._start,
1245 'keymap':self._keymap,
1248 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1250 <screen position="center,120" size="600,350" title="Preference">
1251 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1252 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1254 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1255 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1257 <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" />
1258 <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" />
1261 def __init__(self, session, currentUrl):
1262 self.session = session
1263 Screen.__init__(self, session)
1266 ConfigListScreen.__init__(self, self.menulist)
1268 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1269 "red" : self.keyRed,
1270 "green" : self.keyGreen,
1272 "cancel" : self.keyRed
1274 self["key_red"] = StaticText(_("Cancel"))
1275 self["key_green"] = StaticText(_("Save"))
1276 self["url"] = Label()
1278 self._currentPageUrl = currentUrl
1279 if self._currentPageUrl is None:
1280 self._currentPageUrl = ''
1281 self._startPageUrl = None
1282 self._keymapType = None
1283 self.makeMenuEntry()
1284 self.onLayoutFinish.append(self.layoutFinished)
1286 def layoutFinished(self):
1287 self.setTitle(_('Preference'))
1289 def updateStartPageUrl(self):
1290 if self.menuItemStartpage.value == "startpage":
1291 self["url"].setText(self._startPageUrl)
1292 elif self.menuItemStartpage.value == "current":
1293 self["url"].setText(self._currentPageUrl)
1294 elif self.menuItemStartpage.value == "direct":
1295 self["url"].setText('')
1298 url = self["url"].getText()
1300 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1303 if url.find('/usr/local/manual') > 0:
1305 self._keymapType = self.menuItemKeyboardLayout.value
1306 OperaBrowserSetting().setData(url, mode, self._keymapType)
1307 command_util = getCommandUtil()
1308 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1315 def _cb_directInputUrl(data):
1316 if strIsEmpty(data):
1318 self["url"].setText(data)
1319 if self.menuItemStartpage.value == "direct":
1320 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1323 ConfigListScreen.keyLeft(self)
1324 self.updateStartPageUrl()
1327 ConfigListScreen.keyRight(self)
1328 self.updateStartPageUrl()
1330 def getKeymapTypeList(self):
1332 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1333 filesplit = f.split('.')
1334 if len(filesplit) < 2:
1336 types.append((filesplit[1], filesplit[1]))
1340 def makeMenuEntry(self):
1342 l.append(("startpage", _("Start Page")))
1343 if not strIsEmpty(self._currentPageUrl):
1344 l.append(("current", _("Current Page")))
1345 l.append(("direct", _("Direct Input")))
1346 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1347 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1349 kl = self.getKeymapTypeList()
1352 d = OperaBrowserSetting().getData()
1353 self._startPageUrl = d['start']
1354 self._keymapType = d['keymap']
1356 except: self._startPageUrl = 'http://vuplus.com'
1357 self.updateStartPageUrl()
1359 if self._keymapType is None or len(self._keymapType) == 0:
1360 self._keymapType = "us-rc"
1361 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1362 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1363 self.resetMenuList()
1365 def resetMenuList(self):
1367 self.menulist.append(self.menuEntryStartpage)
1368 self.menulist.append(self.menuEntryKeyboardLayout)
1370 self["config"].list = self.menulist
1371 self["config"].l.setList(self.menulist)
1373 class BookmarkEditWindow(ConfigListScreen, Screen):
1374 CATEGORY,BOOKMARK = 0,1
1376 <screen position="center,center" size="600,140" title="Bookmark Edit">
1377 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1379 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1380 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1382 <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" />
1383 <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" />
1385 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1389 def __init__(self, session, _mode, _type, _data, _bm):
1393 self.mSession = session
1394 self.mBookmarkManager = _bm
1396 if _data is not None:
1399 Screen.__init__(self, session)
1402 ConfigListScreen.__init__(self, self.menulist)
1404 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1405 "ok" : self.keyGreen,
1406 "green" : self.keyGreen,
1407 "red" : self.keyRed,
1408 "cancel" : self.keyRed,
1411 self["VKeyIcon"] = Pixmap()
1412 self["key_red"] = StaticText(_("Cancel"))
1413 self["key_green"] = StaticText(_("Save"))
1415 self.menuItemTitle = None
1416 self.menuItemUrl = None
1417 self.menuItemName = None
1419 self.menuEntryName = None
1420 self.menuEntryTitle = None
1421 self.menuEntryUrl = None
1423 self.makeConfigList()
1424 self.onLayoutFinish.append(self.layoutFinished)
1426 def layoutFinished(self):
1427 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1429 def selectedItem(self):
1430 currentPosition = self["config"].getCurrent()
1431 if self.mType == BookmarkEditWindow.CATEGORY:
1432 return (_("Name"), self.menuItemName)
1434 if currentPosition == self.menuEntryTitle:
1435 return (_("Title"), self.menuItemTitle)
1436 elif currentPosition == self.menuEntryUrl:
1437 return (_("Url"), self.menuItemUrl)
1440 def showMessageBox(self, text):
1441 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the") + " " + text + "."
1442 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1445 def showVKeyWindow(self, data=None):
1448 selected = self.selectedItem()
1449 if selected is not None:
1450 itemValue = selected[1].value
1451 if strIsEmpty(itemValue):
1453 itemTitle = selected[0]
1455 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1457 def cbVKeyWindow(self, data=None):
1458 if data is not None:
1459 selected = self.selectedItem()
1460 if selected is not None:
1461 selected[1].setValue(data)
1464 if self.mType == BookmarkEditWindow.CATEGORY:
1465 if self.mMode == _('Add'):
1466 categoryName = self.menuItemName.value
1467 if strIsEmpty(categoryName):
1468 return self.showMessageBox(_("Category Name"))
1469 self.mBookmarkManager.addCategory(categoryName)
1471 if strIsEmpty(self.menuItemName.value):
1472 return self.showMessageBox(_("Category Name"))
1473 self.mData.mName = self.menuItemName.value
1474 self.mBookmarkManager.updateCategory(self.mData)
1476 if self.mMode == _('Add'):
1477 bookmarkTitle = self.menuItemTitle.value
1478 bookmarkUrl = self.menuItemUrl.value
1479 if strIsEmpty(bookmarkTitle):
1480 self["config"].setCurrentIndex(0)
1481 return self.showMessageBox(_("Bookmark Title"))
1482 if strIsEmpty(bookmarkUrl):
1483 self["config"].setCurrentIndex(1)
1484 return self.showMessageBox(_("Bookmark URL"))
1485 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1487 if strIsEmpty(self.menuItemTitle.value):
1488 self["config"].setCurrentIndex(0)
1489 return self.showMessageBox(_("Bookmark Title"))
1490 if strIsEmpty(self.menuItemUrl.value):
1491 self["config"].setCurrentIndex(1)
1492 return self.showMessageBox(_("Bookmark URL"))
1493 self.mData.mTitle = self.menuItemTitle.value
1494 self.mData.mUrl = self.menuItemUrl.value
1495 self.mBookmarkManager.updateBookmark(self.mData)
1499 if not self.saveData():
1505 ConfigListScreen.keyLeft(self)
1507 ConfigListScreen.keyRight(self)
1508 def makeConfigList(self):
1511 if self.mType == BookmarkEditWindow.CATEGORY:
1512 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1514 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1516 self.menulist.append(self.menuEntryName)
1518 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1519 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1521 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1522 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1524 self.menulist.append(self.menuEntryTitle)
1525 self.menulist.append(self.menuEntryUrl)
1527 self["config"].list = self.menulist
1528 self["config"].l.setList(self.menulist)
1530 class OperaBrowserBookmarkWindow(Screen):
1532 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1533 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1535 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1536 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1538 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1539 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1540 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1541 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1543 <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" />
1544 <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" />
1545 <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" />
1546 <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" />
1550 def __init__(self, _session, _url=None, _title=None):
1552 self.mTitle = _title
1553 self.mBookmarkManager = BookmarkManager.getInstance()
1554 self.mSession = _session
1555 Screen.__init__(self, _session)
1556 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1558 "cancel": self.keyCancel,
1559 "red" : self.keyRed,
1560 "green" : self.keyGreen,
1561 "yellow": self.keyYellow,
1562 "blue" : self.keyBlue,
1563 "0" : self.keyNumber,
1566 self["key_red"] = StaticText(_("Exit"))
1567 self["key_green"] = StaticText(_("Add"))
1568 self["key_yellow"] = StaticText(_("Edit"))
1569 self["key_blue"] = StaticText(_("Delete"))
1570 self["key_0"] = StaticText(_("Set as Startpage"))
1572 self.mBookmarkList = self.setBookmarkList()
1573 self["bookmarklist"] = MenuList(self.mBookmarkList)
1575 self.onLayoutFinish.append(self.layoutFinished)
1577 def layoutFinished(self):
1578 self.setTitle(_('Bookmark'))
1580 def setBookmarkList(self):
1582 #self.mBookmarkManager.dump()
1583 cd = self.mBookmarkManager.getBookmarkRoot()
1584 for ck in cd.iterkeys():
1585 l.append(('# ' + cd[ck].mName, cd[ck]))
1586 bd = cd[ck].mBookmarks
1587 for bk in bd.iterkeys():
1588 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1590 def updateBookmarkList(self):
1591 self.mBookmarkList = self.setBookmarkList()
1592 self["bookmarklist"].setList(self.mBookmarkList)
1593 def cbEditWindow(self, ret=False):
1596 self.updateBookmarkList()
1597 def getParentCategory(self):
1598 idx = self["bookmarklist"].getSelectedIndex()
1601 data = self.mBookmarkList[idx][0].strip()
1603 return self.mBookmarkList[idx][1]
1607 def isCategoryItem(self):
1609 head = self["bookmarklist"].getCurrent()[0].strip()
1614 def keyNumber(self):
1615 data = self["bookmarklist"].getCurrent()[1]
1616 if strIsEmpty(data.mUrl):
1617 msg = _("Invalid URL. Please check again!!")
1618 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1620 def cbSetStartpage(ret=None):
1621 if ret is None: return
1623 data = self["bookmarklist"].getCurrent()[1]
1624 OperaBrowserSetting().setData(data.mUrl, data.mType)
1625 msg = _("Do you want to set selected url to the Startpage?")
1626 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1633 parent = self.getParentCategory()
1636 if strIsEmpty(self.mTitle):
1638 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1640 msg = _("Current page is already exist.")
1641 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1642 self.cbEditWindow(True)
1644 parent = self.getParentCategory()
1647 b = BookmarkData(0, '', '', parent.mId, 0)
1648 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1650 c = CategoryData(0, '')
1651 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1652 if strIsEmpty(self.mUrl):
1653 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1654 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1655 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1656 def keyYellow(self):
1657 data = self["bookmarklist"].getCurrent()[1]
1658 if self.isCategoryItem():
1659 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1660 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1662 def cbBlue(ret=None):
1664 data = self["bookmarklist"].getCurrent()[1]
1665 if self.isCategoryItem():
1666 self.mBookmarkManager.deleteCategory(data.mId)
1667 else: self.mBookmarkManager.deleteBookmark(data.mId)
1668 self.updateBookmarkList()
1669 if self.isCategoryItem():
1670 msg = _("Do you want to delete the category and the bookmarks?")
1671 else: msg = _("Do you want to delete the bookmark?")
1672 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1674 if self.isCategoryItem(): return
1676 data = self["bookmarklist"].getCurrent()[1]
1677 url = data.mUrl.strip()
1679 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1683 lang = language.getLanguage()
1684 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1685 url = '/usr/local/manual/ru_RU/main.html'
1686 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1687 url = '/usr/local/manual/de_DE/main.html'
1688 self.close((url, mode))
1691 def keyCancel(self):
1694 class BrowserHelpWindow(Screen, HelpableScreen):
1695 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1697 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1698 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1699 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1700 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1701 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1703 <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" />
1704 <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" />
1705 <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" />
1706 <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" />
1709 def __init__(self, session):
1710 Screen.__init__(self, session)
1711 HelpableScreen.__init__(self)
1713 self["key_red"] = StaticText(_("Exit"))
1714 self["key_green"] = StaticText(_("Global"))
1715 self["key_yellow"] = StaticText(_("Mouse"))
1716 self["key_blue"] = StaticText(_("Keyboard"))
1718 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1720 "cancel": self.keyRed,
1721 "red" : self.keyRed,
1722 "green" : self.keyGreen,
1723 "yellow": self.keyYellow,
1724 "blue" : self.keyBlue,
1727 self.showHelpTimer = eTimer()
1728 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1729 self.showHelpTimer.start(500)
1731 self.onLayoutFinish.append(self.layoutFinished)
1733 def layoutFinished(self):
1734 self.setTitle(_('Browser Help'))
1736 def cbShowHelpTimerClosed(self):
1737 self.showHelpTimer.stop()
1738 self.setHelpModeActions(self.MODE_GLOBAL)
1740 def setHelpModeActions(self, _mode=0):
1742 if _mode == self.MODE_GLOBAL:
1743 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1744 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1746 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1747 "menu" : (self.keyPass, _("Show the Menu window.")),
1749 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1750 "green" : (self.keyPass, _("Enter Key")),
1751 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1752 "blue" : (self.keyPass, _("Backspace Key")),
1754 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1755 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1758 elif _mode == self.MODE_MOUSE:
1759 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1760 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1761 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1762 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1763 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1765 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1766 "ok" : (self.keyPass, _("Left Mouse Button")),
1768 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1769 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1770 "nextService" : (self.keyPass, _("Left Key")),
1771 "prevService" : (self.keyPass, _("Right Key")),
1773 elif _mode == self.MODE_KEYBOARD:
1774 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1775 "up" : (self.keyPass, _("Up Key")),
1776 "down" : (self.keyPass, _("Down Key")),
1777 "left" : (self.keyPass, _("Left Key")),
1778 "right" : (self.keyPass, _("Right Key")),
1780 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1781 "ok" : (self.keyPass, _("Enter Key")),
1783 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1784 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1785 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1786 "nextService" : (self.keyPass, _("Go to previous page.")),
1787 "prevService" : (self.keyPass, _("Go to next page.")),
1799 self.setHelpModeActions(self.MODE_GLOBAL)
1800 def keyYellow(self):
1801 self.setHelpModeActions(self.MODE_MOUSE)
1803 self.setHelpModeActions(self.MODE_KEYBOARD)
1805 class OperaBrowser(Screen):
1806 MENUBAR_ITEM_WIDTH = 150
1807 MENUBAR_ITEM_HEIGHT = 30
1808 SUBMENULIST_WIDTH = 200
1809 SUBMENULIST_HEIGHT = 25
1810 SUBMENULIST_NEXT = 2
1812 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1813 # menulist->size->x : SUBMENULIST_WIDTH
1814 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1815 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1816 # submenulist->size->x : SUBMENULIST_WIDTH
1818 size = getDesktop(0).size()
1819 WIDTH = int(size.width())
1820 HEIGHT = int(size.height())
1822 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1823 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1824 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1825 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1826 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1827 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1828 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1829 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1831 """ % { 'width' :WIDTH,
1833 'bottom_pos_y' :HEIGHT-80,
1834 'bottom_size_x' :WIDTH }
1838 def __init__(self, session, url=None, isWebAppMode=False):
1839 Screen.__init__(self, session)
1840 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1841 "cancel" : self.keyCancel
1843 ,"left" : self.keyLeft
1844 ,"right" : self.keyRight
1846 ,"down" : self.keyDown
1847 ,"menu" : self.keyMenu
1850 self.UpdateLanguageCB()
1852 self._terminatedBrowser = True
1853 self._enableKeyEvent = True
1854 self._currentPageUrl = None
1855 self._currentPageTitle = None
1856 self.menubarCurrentIndex = 0
1857 self.lvMenuItems = []
1858 self.lvSubMenuItems = []
1860 self["topArea"] = Label()
1861 self["bottomArea"] = Label()
1863 self["menuitemFile"] = MultiColorLabel()# modify menu
1864 self["menuitemTool"] = MultiColorLabel()
1865 self["menuitemHelp"] = MultiColorLabel()
1867 self["menulist"] = MenuList(self.setListOnView())
1868 self["submenulist"] = MenuList(self.setSubListOnView())
1870 self.toggleMainScreenFlag = True
1871 self.toggleListViewFlag = False
1872 self.toggleSubListViewFlag = False
1873 self.currentListView = self["menulist"]
1875 self.onLayoutFinish.append(self.layoutFinished)
1877 self._onCloseTimer = eTimer()
1878 self._onCloseTimer.callback.append(self._cb_onClose)
1881 self.paramIsWebAppMode = isWebAppMode
1882 language.addCallback(self.UpdateLanguageCB)
1884 def UpdateLanguageCB(self):
1886 self.MENUITEMS_LIST = [
1887 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1888 [(_('Bookmark'), None), (_('Preference'), None)],
1889 [(_('About'), None), (_('Help'), None)]]
1890 self.COMMAND_MAP = {}
1891 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1892 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1893 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1894 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1895 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1896 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1897 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1898 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1899 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1901 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1902 rcmouse_path = "/proc/stb/fp/mouse"
1903 if os.path.exists(rcmouse_path):
1904 os.system("echo %d > %s" % (mode, rcmouse_path))
1906 def layoutFinished(self):
1907 self["menuitemFile"].setText(_("File"))# modify menu
1908 self["menuitemTool"].setText(_("Tools"))
1909 self["menuitemHelp"].setText(_("Help"))
1911 self["menulist"].hide()
1912 self["submenulist"].hide()
1914 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1915 self.setTitle(_("BrowserMain"))
1916 self.selectMenuitem()
1918 if self.paramUrl is not None:
1920 if self.paramIsWebAppMode:
1921 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1922 else: self.cbUrlText(data=self.paramUrl, mode=1)
1924 def selectMenuitem(self):
1925 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1926 self["menuitemFile"].setForegroundColorNum(0)
1927 self["menuitemTool"].setForegroundColorNum(0)
1928 self["menuitemHelp"].setForegroundColorNum(0)
1929 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1931 def popupCloseAll(self):
1937 def setListOnView(self):
1938 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1939 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1940 l = [(_('Return'), None)]
1941 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1942 return self.lvMenuItems
1944 def setSubListOnView(self):
1945 self.lvSubMenuItems = []
1946 xl = self["menulist"].getCurrent()[1]
1947 if xl is None: return []
1949 self.lvSubMenuItems.append((x,None))
1950 return self.lvSubMenuItems
1952 def toggleMainScreen(self):
1953 if not self.toggleMainScreenFlag:
1956 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1958 def toggleListView(self):
1959 if not self.toggleListViewFlag:
1960 self["menulist"].show()
1961 else: self["menulist"].hide()
1962 self.toggleListViewFlag = not self.toggleListViewFlag
1964 def toggleSubListView(self):
1965 if not self.toggleSubListViewFlag:
1966 self["submenulist"].show()
1967 else: self["submenulist"].hide()
1968 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1970 def setCurrentListView(self, listViewIdx):
1971 if listViewIdx == 0:
1972 self.currentListView = None
1973 elif listViewIdx == 1:
1974 self.currentListView = self["menulist"]
1975 elif listViewIdx == 2:
1976 self.currentListView = self["submenulist"]
1978 def _cb_onClose(self):
1979 self._onCloseTimer.stop()
1980 command_server = getCommandServer()
1982 if self._on_close_window in command_server.onHbbTVCloseCB:
1983 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1984 except Exception, ErrMsg: pass
1986 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1987 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1988 except Exception, ErrMsg: pass
1989 self._on_setPageTitle(_('Opera Browser'))
1990 self.enableRCMouse(False)
1991 self.toggleMainScreen()
1993 fbClass.getInstance().unlock()
1994 eRCInput.getInstance().unlock()
1995 self._terminatedBrowser = True
1996 self._enableKeyEvent = True
1997 #if not self.toggleListViewFlag:
2000 self._currentPageUrl = ''
2001 if self.paramUrl is not None:
2007 def _on_setPageTitle(self, title=None):
2008 print "Title :",title
2011 self.setTitle(title)
2013 def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
2015 if not _g_helper._is_browser_running():
2017 print "Inputed Url :", data, mode
2018 if strIsEmpty(data):
2021 command_server = getCommandServer()
2022 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
2023 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
2024 if self._on_close_window not in command_server.onHbbTVCloseCB:
2025 command_server.onHbbTVCloseCB.append(self._on_close_window)
2026 self.toggleMainScreen()
2027 self.enableRCMouse(True)
2029 fbClass.getInstance().lock()
2030 eRCInput.getInstance().lock()
2032 #setResolution(1280, 720)
2034 command_util = getCommandUtil()
2035 command_util.sendCommand(opcode, data, mode)
2036 self._terminatedBrowser = False
2037 self._enableKeyEvent = False
2040 __gval__.hbbtv_handelr._soft_volume = -1
2042 def _on_close_window(self):
2043 self._onCloseTimer.start(1000)
2045 def _cb_bookmarkWindowClosed(self, data=None):
2050 if not _g_helper._is_browser_running():
2051 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2052 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2054 self.cbUrlText(url, mode)
2056 def _cmd_on_OpenUrl(self):
2058 if not _g_helper._is_browser_running():
2059 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2060 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2062 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2063 def _cmd_on_About(self):
2064 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2065 def _cmd_on_Exit(self):
2067 def _cb_cmdOnStartSTop(self):
2069 def _cmd_on_StartStop(self):
2071 if _g_helper is None:
2073 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2075 def _cmd_on_Bookmark(self):
2076 url = self._currentPageUrl
2079 title = self._currentPageTitle
2082 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2083 def _cmd_on_Preference(self):
2084 url = self._currentPageUrl
2087 self.session.open(OperaBrowserPreferenceWindow, url)
2088 def _cmd_on_OpenStartpage(self):
2090 if not _g_helper._is_browser_running():
2091 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2092 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2095 start = 'http://vuplus.com'
2097 d = OperaBrowserSetting().getData()
2101 self.cbUrlText(start, mode)
2102 def _cmd_on_ReturnToBrowser(self):
2105 def _cmd_on_Help(self):
2106 self.session.open(BrowserHelpWindow)
2108 def doCommand(self, command):
2110 self.COMMAND_MAP[command]()
2111 except Exception, ErrMsg: print ErrMsg
2114 if not self.toggleMainScreenFlag:
2117 if not self.toggleListViewFlag:
2120 if self.currentListView.getCurrent()[1] is None:
2121 self.doCommand(self.currentListView.getCurrent()[0])
2122 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2126 def updateSelectedMenuitem(self, status):
2127 if self.menubarCurrentIndex == 0 and status < 0:
2128 self.menubarCurrentIndex = 2 # modify menu
2129 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2130 self.menubarCurrentIndex = 0
2131 else: self.menubarCurrentIndex += status
2132 self.selectMenuitem()
2135 if not self.toggleMainScreenFlag:
2137 if not self.toggleListViewFlag:
2138 self.updateSelectedMenuitem(-1)
2140 if self.toggleSubListViewFlag:
2141 self.setCurrentListView(1)
2142 self.toggleSubListView()
2144 #if self.currentListView.getSelectedIndex():
2145 self.currentListView.pageUp()
2151 if not self.toggleMainScreenFlag:
2153 if not self.toggleListViewFlag:
2154 self.updateSelectedMenuitem(1)
2156 if self.currentListView is None:
2158 if self.currentListView.getCurrent()[1] is not None:
2159 parentSelectedIndex = self.currentListView.getSelectedIndex()
2160 self.setCurrentListView(2)
2161 self.currentListView.setList(self.setSubListOnView())
2162 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2163 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))
2164 self.toggleSubListView()
2166 self.currentListView.pageUp()
2172 if not self.toggleMainScreenFlag:
2174 if self.currentListView is None:
2176 if not self.toggleListViewFlag:
2177 self.currentListView.setList(self.setListOnView())
2178 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2179 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2180 self.toggleListView()
2182 self.currentListView.down()
2185 if not self.toggleMainScreenFlag:
2187 if self.currentListView is None:
2189 if self.currentListView == self["menulist"]:
2190 if self.currentListView.getSelectedIndex() == 0:
2191 self.toggleListView()
2193 self.currentListView.up()
2195 def keyCancel(self):
2196 if not self._terminatedBrowser:
2197 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2198 fbClass.getInstance().lock()
2199 eRCInput.getInstance().lock()
2200 #setResolution(1280, 720)
2201 if self.toggleListViewFlag:
2202 self.toggleMainScreen()
2203 self._currentPageUrl = None
2204 self._currentPageTitle = None
2205 command_util = getCommandUtil()
2206 command_util.sendCommand('OP_BROWSER_MENU_RES')
2211 self.toggleMainScreen()
2213 def setCurrentPageUrl(self, url, title=None):
2214 self._currentPageUrl = url
2217 if idx > 10: idx = 10
2219 self._currentPageTitle = title
2220 print self._currentPageUrl
2221 self.toggleMainScreen()
2225 def hideSubmenu(self):
2226 self.currentListView.pageUp()
2229 config.plugins.youtubetv = ConfigSubsection()
2230 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2231 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2232 class YoutubeTVWindow(Screen, HelpableScreen):
2234 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2235 <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2236 <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2237 <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2238 <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2239 <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2240 <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" />
2241 <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" />
2244 def __init__(self, session):
2245 Screen.__init__(self, session)
2246 HelpableScreen.__init__(self)
2248 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2249 "cancel": self.keyCancel,
2250 "red" : self.keyCancel,
2251 "green" : self.keyGreen,
2252 "yellow": self.keyYellow,
2255 self["key_green"] = StaticText(_("Start"))
2256 self["key_yellow"] = StaticText(_("Help"))
2258 self["infomation"] = Label()
2259 self["startdesc"] = Label()
2260 self["helpdesc"] = Label()
2262 self.onLayoutFinish.append(self.layoutFinished)
2264 def layoutFinished(self):
2265 self.setTitle(_('Start YouTube TV'))
2266 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2267 self["startdesc" ].setText(_("* Start YouTube TV"))
2268 self["helpdesc" ].setText(_("* RC Help"))
2270 def setHelpModeActions(self):
2272 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2273 "ok" : (self.keyPass, _("Play ther selected the video")),
2274 "cancel": (self.keyPass, _("Exit the YouTube TV")),
2276 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2277 "pageUp" : (self.keyPass, _("Move up")),
2278 "pageDown" : (self.keyPass, _("Move down")),
2279 "prevEvent" : (self.keyPass, _("Move left")),
2280 "nextEvent" : (self.keyPass, _("Move right")),
2282 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2283 "info" : (self.keyPass, _("Search a video")),
2284 "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2285 "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2287 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2288 "play" : (self.keyPass, _("Play current video")),
2289 "pause" : (self.keyPass, _("Pause current video")),
2290 "stop" : (self.keyPass, _("Stop current video")),
2292 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2293 "red" : (self.keyPass, _("Back")),
2299 def keyCancel(self):
2300 config.plugins.youtubetv.showhelp.cancel()
2303 config.plugins.youtubetv.showhelp.save()
2304 config.plugins.youtubetv.save()
2305 config.plugins.save()
2307 def keyYellow(self):
2308 self.setHelpModeActions()
2310 if config.plugins.youtubetv.showhelp.value == True :
2311 config.plugins.youtubetv.showhelp.setValue(False)
2312 else: config.plugins.youtubetv.showhelp.setValue(True)
2314 class YoutubeTVSettings(ConfigListScreen, Screen):
2316 <screen position="center,center" size="600,140" title="YouTube TV Settings">
2317 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2319 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2320 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2322 <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" />
2323 <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" />
2326 def __init__(self, session):
2327 self.session = session
2328 Screen.__init__(self, session)
2331 ConfigListScreen.__init__(self, self.menulist)
2333 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2334 "ok" : self.keyGreen,
2335 "green" : self.keyGreen,
2336 "red" : self.keyRed,
2337 "cancel" : self.keyRed,
2340 self["key_red"] = StaticText(_("Cancel"))
2341 self["key_green"] = StaticText(_("Save"))
2343 self.makeConfigList()
2344 self.onLayoutFinish.append(self.layoutFinished)
2346 def layoutFinished(self):
2347 self.setTitle(_('YouTube TV Settings'))
2350 config.plugins.youtubetv.showhelp.save()
2351 config.plugins.youtubetv.uri.save()
2352 config.plugins.youtubetv.save()
2353 config.plugins.save()
2356 config.plugins.youtubetv.showhelp.cancel()
2357 config.plugins.youtubetv.uri.cancel()
2361 ConfigListScreen.keyLeft(self)
2364 ConfigListScreen.keyRight(self)
2366 def makeConfigList(self):
2368 entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2369 entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Starter again"), config.plugins.youtubetv.showhelp)
2370 self.menulist.append(entryUri)
2371 self.menulist.append(entryShowHelp)
2373 self["config"].list = self.menulist
2374 self["config"].l.setList(self.menulist)
2376 def auto_start_main(reason, **kwargs):
2378 command_server = getCommandServer()
2379 command_server.stop()
2381 from Screens.HelpMenu import HelpableScreen
2382 def session_start_main(session, reason, **kwargs):
2383 fbClass.getInstance().unlock()
2384 eRCInput.getInstance().unlock()
2386 from enigma import getDesktop
2387 desktopSize = getDesktop(0).size()
2388 setDefaultResolution(desktopSize.width(), desktopSize.height())
2391 _g_helper = session.open(HbbTVHelper)
2393 HelpableScreen.__init__ = HelpableScreen__init__
2394 HelpableScreen.session = session
2396 def HelpableScreen__init__(self):
2397 if isinstance(self, HelpableScreen):
2398 HelpableScreen.showManual = showManual
2400 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2401 "help_b" : self.showHelp,
2402 "help_l" : self.showManual,
2405 _g_clearBrowserDataTimer = eTimer()
2406 def showManual(self):
2407 if not os.path.exists('/usr/local/manual'):
2410 url = 'file:///usr/local/manual/main.html'
2411 lang = language.getLanguage()
2412 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2413 url = 'file:///usr/local/manual/ru_RU/main.html'
2414 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2415 url = 'file:///usr/local/manual/de_DE/main.html'
2418 _g_clearBrowserDataTimer.stop()
2419 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2421 setPluginBrowser(None)
2423 def clearBrowserData():
2424 _g_clearBrowserDataTimer.callback.append(_do_clean)
2425 _g_clearBrowserDataTimer.start(50)
2426 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2428 _g_backupSession = None
2429 def showYoutubeTV(session, **kwargs):
2431 _g_clearBrowserDataTimer.stop()
2432 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2434 setPluginBrowser(None)
2435 global _g_backupSession
2437 service = getBeforeService()
2438 if service is not None:
2439 _g_backupSession.nav.playService(eServiceReference(service))
2440 _g_backupSession = None
2441 def clearBrowserData():
2442 _g_clearBrowserDataTimer.callback.append(_do_clean)
2443 _g_clearBrowserDataTimer.start(50)
2444 def cbYoutubeTVClose(ret):
2446 global _g_backupSession
2447 _g_backupSession = session
2448 service = session.nav.getCurrentlyPlayingServiceReference()
2449 if service is not None:
2450 setBeforeService(service.toString())
2451 session.nav.stopService()
2452 else: setBeforeService(service)
2453 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2454 if config.plugins.youtubetv.showhelp.value == True:
2455 cbYoutubeTVClose(True)
2456 else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2458 def youtube_setting_main(session, **kwargs):
2459 session.open(YoutubeTVSettings)
2461 def start_menu_main(menuid, **kwargs):
2462 if menuid == "mainmenu":
2463 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2466 def plugin_start_main(session, **kwargs):
2467 #session.open(OperaBrowser)
2469 _g_clearBrowserDataTimer.stop()
2470 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2472 setPluginBrowser(None)
2473 def clearBrowserData():
2474 _g_clearBrowserDataTimer.callback.append(_do_clean)
2475 _g_clearBrowserDataTimer.start(50)
2476 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2478 def plugin_extension_start_application(session, **kwargs):
2480 if _g_helper is None:
2482 _g_helper.showApplicationSelectionBox()
2484 def plugin_extension_browser_config(session, **kwargs):
2486 if _g_helper is None:
2488 _g_helper.showBrowserConfigBox()
2490 def Plugins(path, **kwargs):
2492 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2493 l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2494 l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2495 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2496 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2497 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2498 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))