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_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
187 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
188 ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
189 ,"OP_VOD_URI" : 0x0201
190 ,"OP_VOD_PLAY" : 0x0202
191 ,"OP_VOD_STOP" : 0x0203
192 ,"OP_VOD_PAUSE" : 0x0204
193 ,"OP_VOD_STATUS" : 0x0205
194 ,"OP_VOD_FORBIDDEN" : 0x0206
195 ,"OP_VOD_STOPED" : 0x0207
196 ,"OP_VOD_SPEED_CTRL" : 0x0208
197 ,"OP_VOD_SEEK_CTRL" : 0x0209
198 ,"OP_BROWSER_OPEN_URL" : 0x0301
199 ,"OP_BROWSER_VKBD_REQ" : 0x0309
200 ,"OP_BROWSER_VKBD_RES" : 0x030A
201 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
202 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
203 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
204 ,"OP_BROWSER_MENU_REQ" : 0x030E
205 ,"OP_BROWSER_MENU_RES" : 0x030F
206 ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
207 ,"OP_DVBAPP_VOL_UP" : 0x0401
208 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
209 ,"OP_DVBAPP_SET_VOL" : 0x0403
210 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
211 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
212 ,"OP_VIDEOBACKEND_ENABLE" : 0x0601
213 ,"OP_VIDEOBACKEND_DISABLE" : 0x0602
214 ,"OP_BROWSER_OPEN_YOUTUBETV" : 0x0603
217 0x0000 : "OP_UNKNOWN"
218 ,0x0001 : "OP_HBBTV_EXIT"
219 ,0x0002 : "OP_HBBTV_OPEN_URL"
220 ,0x0003 : "OP_HBBTV_LOAD_AIT"
221 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
222 ,0x0005 : "OP_HBBTV_FULLSCREEN"
223 ,0x0006 : "OP_HBBTV_TITLE"
224 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
225 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
226 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
227 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
228 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
229 ,0x0201 : "OP_VOD_URI"
230 ,0x0202 : "OP_VOD_PLAY"
231 ,0x0203 : "OP_VOD_STOP"
232 ,0x0204 : "OP_VOD_PAUSE"
233 ,0x0205 : "OP_VOD_STATUS"
234 ,0x0206 : "OP_VOD_FORBIDDEN"
235 ,0x0207 : "OP_VOD_STOPED"
236 ,0x0208 : "OP_VOD_SPEED_CTRL"
237 ,0x0209 : "OP_VOD_SEEK_CTRL"
238 ,0x0301 : "OP_BROWSER_OPEN_URL"
239 ,0x0309 : "OP_BROWSER_VKBD_REQ"
240 ,0x030A : "OP_BROWSER_VKBD_RES"
241 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
242 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
243 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
244 ,0x030E : "OP_BROWSER_MENU_REQ"
245 ,0x030F : "OP_BROWSER_MENU_RES"
246 ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
247 ,0x0401 : "OP_DVBAPP_VOL_UP"
248 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
249 ,0x0403 : "OP_DVBAPP_SET_VOL"
250 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
251 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
252 ,0x0601 : "OP_VIDEOBACKEND_ENABLE"
253 ,0x0602 : "OP_VIDEOBACKEND_DISABLE"
254 ,0x0603 : "OP_BROWSER_OPEN_YOUTUBETV"
257 def get(self, opstr):
259 return self._opcode_[opstr]
261 return self._opcode_["OP_UNKNOWN"]
263 def what(self, opcode):
265 return self._opstr_[opcode]
267 return self._opstr_["0x0000"]
280 def __init__(self, params):
281 self._protocol = params.protocol
282 self._type = params.type
283 self._addr = params.addr
284 self._buf_size = params.buf_size
285 self._handler = params.handler
286 self._timeout = params.timeout
287 self._destroy = params.destroy
289 self._terminated = False
290 self._server_thread = None
292 self.onHbbTVCloseCB = []
293 self.onSetPageTitleCB = []
296 if self._destroy is not None:
297 self._destroy(self._addr)
300 self._terminated = True
301 if self._server_thread is not None:
302 self._server_thread.join()
303 self._server_thread = None
306 self._socket = socket.socket(self._protocol, self._type)
307 self._socket.settimeout(self._timeout)
308 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
309 self._socket.bind(self._addr)
310 self._socket.listen(True)
312 self._server_thread = threading.Thread(target=self._listen)
313 self._server_thread.start()
316 select_list = [self._socket]
319 conn, addr = self._socket.accept()
320 self._client(conn, addr)
321 except Exception, ErrMsg:
322 print "ServerSocket Error >>", ErrMsg
325 while not self._terminated:
326 readable, writable, errored = select.select(select_list, [], [], self._timeout)
328 if s is self._socket:
331 def _client(self, conn, addr):
334 received_data = conn.recv(self._buf_size)
335 if self._handler is not None and not strIsEmpty(received_data):
336 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
337 self._send(conn, send_data)
338 except Exception, ErrMsg:
341 if self._handler is not None:
342 self._handler.printError(ErrMsg)
343 def _send(self, conn, data) :
348 def doListenUnixTCP(self, name, handler):
352 if os.path.exists(name):
354 print "Removed ", name
358 params = SocketParams()
359 params.protocol = socket.AF_UNIX
360 params.type = socket.SOCK_STREAM
362 params.handler = handler
363 params.destroy = destroy
365 streamServer = StreamServer(params)
369 def doListenInetTCP(self, ip, port, handler):
370 print "Not implemented yet!!"
371 def doListenUnixDGRAM(self, name, handler):
372 print "Not implemented yet!!"
373 def doListenInetDGRAM(self, ip, port, handler):
374 print "Not implemented yet!!"
377 def doUnpack(self, data):
380 def doPack(self, opcode, params, reserved=0):
381 return _pack(opcode, params, reserved)
383 def doHandle(self, data, onCloseCB):
384 opcode, params = 0x0, 'Invalid Request!!'
385 return _pack(opcode, params)
387 def printError(self, reason):
390 class BrowserCommandUtil(OpCodeSet):
393 OpCodeSet.__init__(self)
395 def isConnected(self):
400 def doConnect(self, filename):
401 if not os.path.exists(filename):
402 print "File not exists :", filename
405 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
407 print "Fail to open file :", filename
409 except Exception, ErrMsg:
415 def doDisconnect(self):
421 def doSend(self, command, params=None, reserved=0):
423 print "No found pipe!!"
427 data = _pack(self.get(command), params, reserved)
430 os.write(self._fd, data)
431 print "Send OK!! :", command
435 def sendCommand(self, command, params=None, reserved=0):
436 if not self.isConnected():
438 self.doConnect(COMMAND_PATH)
439 result = self.doSend(command, params, reserved)
443 class HandlerHbbTV(Handler):
445 def __init__(self, session):
446 self._session = session
447 self.opcode = OpCodeSet()
449 0x0001 : self._cb_handleCloseHbbTVBrowser
450 ,0x0006 : self._cb_handleSetPageTitle
451 ,0x0009 : self._cb_handleHbbTVRetryOpen
452 ,0x000A : self._cb_handleHbbTVChangeChannel
453 ,0x0101 : self._cb_handleGetChannelInfoForUrl
454 ,0x0102 : self._cb_handleGetChannelInfoForAIT
455 ,0x0103 : self._cb_handleGetChannelInfoList
456 ,0x0201 : self._cb_handleVODPlayerURI
457 ,0x0202 : self._cb_handleVODPlayerPlay
458 ,0x0203 : self._cb_handleVODPlayerStop
459 ,0x0204 : self._cb_handleVODPlayerPlayPause
460 ,0x0401 : self._cb_handleDVBAppVolUp
461 ,0x0402 : self._cb_handleDVBAppVolDown
462 ,0x0403 : self._cb_handleDVBAppSetVol
463 ,0x0208 : self._cb_handleVODSpeedCtrl
464 ,0x0209 : self._cb_handleVODSeekCtrl
465 ,0x0501 : self._cb_handleSystemOutOfMemory
466 ,0x0502 : self._cb_handleSystemNotufyMyPID
467 ,0x0309 : self._cb_handleShowVirtualKeyboard
468 ,0x030B : self._cb_handlePasteVirtualKeyboard
469 ,0x030E : self._cb_handleBrowserMenuReq
470 ,0x0601 : self._cb_handleVideobackendEnable
471 ,0x0602 : self._cb_handleVideobackendDisable
473 self._on_close_cb = None
474 self._on_set_title_cb = None
478 self._retry_open_url = None
479 self._timer_retry_open = eTimer()
480 self._timer_paste_vkbd = eTimer()
481 self._curren_title = None
483 def _handle_dump(self, handle, opcode, data=None):
487 print " - opcode : ", self.opcode.what(opcode)
489 print " - data : ", data
491 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
492 opcode, params, reserved = None, None, 0
493 self._on_close_cb = onCloseCB
494 self._on_set_title_cb = onSetPageTitleCB
496 datas = self.doUnpack(data)
497 except Exception, ErrMsg:
498 print "Unpacking packet ERR :", ErrMsg
499 params = 'fail to unpack packet!!'
500 opcode = self.opcode.get("OP_UNKNOWN")
501 return self.doPack(opcode, params)
505 self.opcode.what(opcode)
508 #print self.handle_map[opcode]
509 (reserved, params) = self.handle_map[opcode](opcode, params)
510 except Exception, ErrMsg:
511 print "Handling packet ERR :", ErrMsg
512 params = 'fail to handle packet!!'
513 opcode = self.opcode.get("OP_UNKNOWN")
514 return self.doPack(opcode, params)
515 self._on_close_cb = None
516 self._on_set_title_cb = None
517 return self.doPack(opcode, params, reserved)
519 def _cb_handleVideobackendEnable(self, opcode, data):
520 self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
521 service = self._session.nav.getCurrentlyPlayingServiceReference()
522 setBeforeService(service)
523 self._session.nav.stopService()
526 def _cb_handleVideobackendDisable(self, opcode, data):
527 self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
528 before_service = getBeforeService()
529 self._session.nav.playService(before_service)
532 def _cb_handleHbbTVChangeChannel(self, opcode, data):
533 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
535 if _g_helper is None:
537 dataItems = data.split(":")
540 if not _g_helper.doChangeChannel(sid, tsid):
544 def _cb_handleBrowserMenuReq(self, opcode, data):
545 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
547 fbClass.getInstance().unlock()
548 eRCInput.getInstance().unlock()
549 browser = getPluginBrowser()
550 if browser is not None:
551 browser.setCurrentPageUrl(data, self._curren_title)
554 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
555 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
556 def _cb_PasteRefocusVirtualKeyboard():
557 self._timer_paste_vkbd.stop()
558 command_util = getCommandUtil()
559 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
561 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
563 def _cb_PasteKeyVirtualKeyboard():
564 self._timer_paste_vkbd.stop()
565 command_util = getCommandUtil()
566 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
568 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
570 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
571 self._timer_paste_vkbd.start(100)
572 def _cb_PasteMouseVirtualKeyboard():
573 self._timer_paste_vkbd.stop()
574 command_util = getCommandUtil()
575 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
577 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
579 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
581 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
582 #self._timer_paste_vkbd.start(1000)
583 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
584 self._timer_paste_vkbd.start(50)
587 def _cb_virtualKeyboardClosed(self, data=None):
588 fbClass.getInstance().lock()
589 eRCInput.getInstance().lock()
590 #setResolution(1280, 720)
591 command_util = getCommandUtil()
592 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
594 def _cb_handleShowVirtualKeyboard(self, opcode, data):
595 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
597 fbClass.getInstance().unlock()
598 eRCInput.getInstance().unlock()
599 if data == 0 or strIsEmpty(data):
601 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
604 def _cb_handleVODSeekCtrl(self, opcode, data):
605 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
606 headLen = struct.calcsize('!I')
607 unpackedData = struct.unpack('!I', data[:headLen])
608 seekTime = unpackedData[0]
609 service = self._session.nav.getCurrentService()
610 seekable = service.seek()
611 if seekable is None or not seekable.isCurrentlySeekable():
612 raise Exception("This stream is not support manual seek.")
614 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
617 def _cb_handleHbbTVRetryOpen(self, opcode, data):
618 def _cb_HbbTVRetryOpenURL():
619 self._timer_retry_open.stop()
620 if self._retry_open_url is not None:
621 command_util = getCommandUtil()
622 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
623 self._retry_open_url = None
625 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
627 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
628 headLen = struct.calcsize('!I')
629 unpackedData = struct.unpack('!I', data[:headLen])
630 delayTime = unpackedData[0]
631 restartUrl = data[headLen:]
633 self._retry_open_url = restartUrl.strip()
634 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
635 self._timer_retry_open.start(delayTime*1000)
638 def _cb_handleSystemNotufyMyPID(self, opcode, data):
639 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
642 def _cb_handleSystemOutOfMemory(self, opcode, data):
643 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
647 def _cb_handleVODSpeedCtrl(self, opcode, data):
648 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
649 headLen = struct.calcsize('!I')
650 unpackedData = struct.unpack('!I', data[:headLen])
651 playSpeed = unpackedData[0]
652 service = self._session.nav.getCurrentService()
653 pauseable = service.pause()
656 if pauseable.setFastForward(playSpeed) == -1:
657 pauseable.setFastForward(1)
658 raise Exception("This stream is not support trick play.")
661 def _cb_handleDVBAppVolUp(self, opcode, data):
662 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
663 vcm = VolumeControl.instance
667 def _cb_handleDVBAppVolDown(self, opcode, data):
668 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
669 vcm = VolumeControl.instance
673 def _cb_handleDVBAppSetVol(self, opcode, data):
674 self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data)
676 VolumeControl.instance.volctrl.setVolume(v, v)
679 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
680 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
681 (sid, onid, tsid, name, orgid) = getChannelInfos()
683 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
685 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
686 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
687 (sid, onid, tsid, name, orgid) = getChannelInfos()
689 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
691 def _cb_handleGetChannelInfoList(self, opcode, data):
692 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
693 (sid, onid, tsid, name, orgid) = getChannelInfos()
695 channel_list_size = 1
696 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
698 def _cb_handleSetPageTitle(self, opcode, data):
699 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
700 if data.startswith('file://') or data.startswith('http://'):
702 if self._on_set_title_cb is not None:
703 for x in self._on_set_title_cb:
706 self._curren_title = data
707 except Exception, ErrMsg:
708 if x in self._on_set_title_cb:
709 self._on_set_title_cb.remove(x)
712 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
713 self._timer_retry_open.stop()
715 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
717 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
719 if self._on_close_cb:
720 for x in self._on_close_cb:
723 except Exception, ErrMsg:
724 if x in self._on_close_cb:
725 self._on_close_cb.remove(x)
727 command_util = getCommandUtil()
728 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
730 before_service = getBeforeService()
731 if before_service is not None:
732 self._session.nav.playService(before_service)
738 def _cb_handleVODPlayerURI(self, opcode, data):
740 hl = struct.calcsize('!II')
741 datas = struct.unpack('!II', data[:hl])
743 vodUri = data[hl:hl+uriLength]
744 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
745 self._vod_uri = vodUri
748 def doStop(self, restoreBeforeService=True, needStop=True):
750 self._session.nav.stopService()
751 if self._vod_service is not None and restoreBeforeService:
752 before_service = getBeforeService()
753 self._session.nav.playService(before_service)
755 self._vod_service = None
760 def doRetryOpen(self, url):
764 self._vod_service = None
766 #print "Try to open vod [%d] : %s" % (ii, url)
767 print "Try to open vod"
768 self._vod_service = eServiceReference(4097, 0, url)
769 self._session.nav.playService(self._vod_service)
770 if self._vod_service is not None:
772 except Exception, ErrMsg:
773 print "OpenVOD ERR :", ErrMsg
777 def _cb_handleVODPlayerPlay(self, opcode, data):
778 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
779 self.doStop(restoreBeforeService=False)
780 if self.doRetryOpen(url=self._vod_uri) == False:
784 def _cb_handleVODPlayerStop(self, opcode, data):
785 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
789 def _cb_handleVODPlayerPlayPause(self, opcode, data):
790 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
791 service = self._session.nav.getCurrentService()
794 servicePause = service.pause()
796 servicePause.unpause()
797 elif pauseFlag == 'P':
799 except Exception, ErrMsg:
800 print "onPause ERR :", ErrMsg
803 from libshm import SimpleSharedMemory
805 class HbbTVWindow(Screen, InfoBarNotifications):
807 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
810 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
811 self._session = session
812 setResolution(1280, 720)
813 fbClass.getInstance().lock()
814 eRCInput.getInstance().lock()
816 Screen.__init__(self, session)
817 InfoBarNotifications.__init__(self)
818 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
819 iPlayableService.evStart: self._serviceStarted,
820 iPlayableService.evEOF: self._serviceEOF,
824 self._use_ait = useAIT
825 self._profile = profile
826 self._cb_closed_func = cbf
827 self.onLayoutFinish.append(self._layoutFinished)
829 command_server = getCommandServer()
830 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
831 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
833 if self._cb_close_window not in command_server.onHbbTVCloseCB:
834 command_server.onHbbTVCloseCB.append(self._cb_close_window)
836 self._closeTimer = eTimer()
837 self._closeTimer.callback.append(self._do_close)
839 self._currentServicePositionTimer = eTimer()
840 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
847 def getVodPlayTime(self):
849 service = self._session.nav.getCurrentService()
850 seek = service and service.seek()
852 p = seek.getPlayPosition()
853 if(not l[0] and not p[0]):
859 def _cb_currentServicePosition(self):
860 def getTimeString(t):
861 t = time.localtime(t/90000)
862 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
863 position,length = 0,0
865 (position,length) = self.getVodPlayTime()
866 self._vod_length = length
867 if position == -1 and length == -1:
868 raise Exception("Can't get play status")
869 #print getTimeString(position), "/", getTimeString(length)
870 self._ssm.setStatus(position, length, 1)
871 except Exception, ErrMsg:
875 def _serviceStarted(self):
877 self._ssm.setStatus(0, 0, 0)
878 self._currentServicePositionTimer.start(1000)
879 except Exception, ErrMsg:
882 def _serviceEOF(self):
883 (position,length) = self.getVodPlayTime()
884 self._ssm.setStatus(length, length, 1)
886 self._currentServicePositionTimer.stop()
888 def _layoutFinished(self):
889 self.setTitle(_('HbbTV Plugin'))
890 command_util = getCommandUtil()
891 profile = self._profile
892 (sid, onid, tsid, name, orgid) = getChannelInfos()
893 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
895 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
897 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
899 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
901 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
903 def _cb_close_window(self):
904 self._closeTimer.start(1000)
907 self._closeTimer.stop()
908 command_server = getCommandServer()
910 if self._cb_set_page_title in command_server.onSetPageTitleCB:
911 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
912 except Exception, ErrMsg: pass
914 if self._cb_close_window in command_server.onHbbTVCloseCB:
915 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
916 except Exception, ErrMsg: pass
918 if self._cb_closed_func is not None:
919 self._cb_closed_func()
922 fbClass.getInstance().unlock()
923 eRCInput.getInstance().unlock()
926 def _cb_set_page_title(self, title=None):
927 print "page title :",title
932 class HbbTVHelper(Screen, InfoBarNotifications):
933 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
934 def __init__(self, session):
936 __gval__.hbbtv_handelr = HandlerHbbTV(session)
937 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
939 Screen.__init__(self, session)
940 InfoBarNotifications.__init__(self)
942 self._session = session
944 self._restart_opera()
946 self._timer_infobar = eTimer()
947 self._timer_infobar.callback.append(self._cb_registrate_infobar)
948 self._timer_infobar.start(1000)
950 self._excuted_browser = False
953 __gval__.command_util = BrowserCommandUtil()
957 _g_ssm_ = SimpleSharedMemory()
960 self._callbackStartStop = None
962 self.__et = ServiceEventTracker(screen=self, eventmap={
963 iPlayableService.evHBBTVInfo: self._cb_detectedAIT,
964 iPlayableService.evUpdatedInfo: self._cb_updateInfo
966 self._applicationList = None
968 self.mVuplusBox = False
969 issue = open("/etc/issue").read()
970 if(issue.startswith("Vuplus")):
971 self.mVuplusBox = True
973 def _cb_detectedAIT(self):
974 name = self._cb_ready_for_ait()
975 if name is not None and self.mVuplusBox:
976 from Screens.InfoBarGenerics import gHbbtvApplication
977 gHbbtvApplication.setApplicationName(str(name))
979 def _cb_updateInfo(self):
980 if not self._excuted_browser:
981 command_util = getCommandUtil()
982 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
984 from Screens.InfoBarGenerics import gHbbtvApplication
985 gHbbtvApplication.setApplicationName("")
986 #self._applicationList = None
988 def _cb_registrate_infobar(self):
990 self._timer_infobar.stop()
991 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
992 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
994 def _cb_ready_for_ait(self):
995 setChannelInfo(None, None, None, None, None)
997 service = self._session.nav.getCurrentService()
998 info = service and service.info()
1000 sid = info.getInfo(iServiceInformation.sSID)
1001 onid = info.getInfo(iServiceInformation.sONID)
1002 tsid = info.getInfo(iServiceInformation.sTSID)
1003 name = info.getName()
1007 pmtid = info.getInfo(iServiceInformation.sPMTPID)
1008 demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
1010 from aitreader import eAITSectionReader
1011 reader = eAITSectionReader(demux, pmtid, sid)
1012 if reader.doOpen(info, self.mVuplusBox):
1013 reader.doParseApplications()
1015 else: print "no data!!"
1018 self._applicationList = reader.getApplicationList()
1019 if len(self._applicationList) > 0:
1020 orgid = int(self._applicationList[0]["orgid"])
1021 setChannelInfo(sid, onid, tsid, name, orgid)
1022 return self._applicationList[0]["name"]
1026 def _cb_hbbtv_activated(self, title=None, url=None):
1027 if not self._is_browser_running():
1028 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1029 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1031 service = self._session.nav.getCurrentlyPlayingServiceReference()
1032 setBeforeService(service)
1033 self._start_hbbtv_application(title, url)
1035 def _start_hbbtv_application(self, title, url):
1037 tmp_url = self.getStartHbbTVUrl()
1041 print "can't get url of hbbtv!!"
1043 print "success to get url of hbbtv!! >>", url
1044 if self._excuted_browser:
1045 print "already excuted opera browser!!"
1049 self._restart_opera()
1051 setNeedRestart(False)
1053 for x in self._applicationList:
1054 control_code = int(x["control"])
1056 if tmp_url == url and control_code == 1:
1058 self._excuted_browser = True
1059 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1061 def _cb_closed_browser(self):
1062 self._excuted_browser = False
1064 def _start_opera(self):
1065 if not self._is_browser_running():
1066 global HBBTVAPP_PATH
1068 start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
1069 os.system(start_command)
1072 def _stop_opera(self):
1073 global HBBTVAPP_PATH
1074 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1077 def _restart_opera(self):
1078 global HBBTVAPP_PATH
1080 try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
1084 def getStartHbbTVUrl(self):
1085 url, self._profile = None, 0
1086 if self._applicationList is not None:
1087 self._profile = self._applicationList[0]["profile"]
1088 url = self._applicationList[0]["url"]
1090 service = self._session.nav.getCurrentService()
1091 info = service and service.info()
1092 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1095 def showApplicationSelectionBox(self):
1098 if self.getStartHbbTVUrl():
1099 for x in self._applicationList:
1100 applications.append((x["name"], x))
1101 else: applications.append((_("No detected HbbTV applications."), None))
1102 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1104 def _application_selected(self, selected):
1107 if selected[1] is None: return
1108 self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
1109 except Exception, ErrMsg: print ErrMsg
1111 def showBrowserConfigBox(self, callback=None):
1112 start_stop_mode = []
1113 self._callbackStartStop = callback
1114 if self._is_browser_running():
1115 start_stop_mode.append((_('Stop'),'Stop'))
1116 else: start_stop_mode.append((_('Start'),'Start'))
1117 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1119 def _browser_config_selected(self, selected):
1120 if selected is None:
1122 if self._callbackStartStop is not None:
1123 self._callbackStartStop()
1127 if not self._is_browser_running():
1129 elif mode == 'Stop':
1131 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1133 def _is_browser_running(self):
1135 global HBBTVAPP_PATH
1136 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1137 return ret.strip() != "0"
1138 except Exception, ErrMsg:
1139 print "Check Browser Running ERR :", ErrMsg
1142 def doChangeChannel(self, _sid, _tsid):
1143 root = eServiceReference(service_types_tv)
1146 serviceList = eServiceCenter.getInstance().list(root)
1147 if serviceList is None:
1150 service = serviceList.getNext()
1151 if service is None or not service.valid():
1154 #1:0:19:2840:3FB:1:C00000:0:0:0:
1155 serviceRef = service.toString()
1156 if strIsEmpty(serviceRef):
1158 serviceRefItems = serviceRef.split(":")
1159 if len(serviceRefItems) < 5:
1162 sid = serviceRefItems[3]
1163 tsid = serviceRefItems[4]
1164 if sid == _sid and tsid == _tsid:
1165 self._session.nav.playService(eServiceReference(serviceRef))
1166 service = self._session.nav.getCurrentlyPlayingServiceReference()
1167 setBeforeService(service)
1171 class OperaBrowserSetting:
1173 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1179 f = open(self._settingFileName)
1180 for line in f.readlines():
1181 if line.startswith('start='):
1182 tmp = line[6:len(line)-1].split()
1183 self._start = tmp[0]
1185 self._type = int(tmp[1])
1186 else: self._type = 0
1187 elif line.startswith('keymap='):
1188 self._keymap = line[7:len(line)-1]
1192 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1193 tmpstr.append('keymap=%s\n' % (self._keymap))
1194 f = open(self._settingFileName, 'w')
1195 f.writelines(tmpstr)
1197 def setData(self, start, types=0, keymap="us-rc"):
1200 self._keymap = keymap
1204 'start':self._start,
1206 'keymap':self._keymap,
1209 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1211 <screen position="center,120" size="600,350" title="Preference">
1212 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1213 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1215 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1216 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1218 <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" />
1219 <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" />
1222 def __init__(self, session, currentUrl):
1223 self.session = session
1224 Screen.__init__(self, session)
1227 ConfigListScreen.__init__(self, self.menulist)
1229 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1230 "red" : self.keyRed,
1231 "green" : self.keyGreen,
1233 "cancel" : self.keyRed
1235 self["key_red"] = StaticText(_("Cancel"))
1236 self["key_green"] = StaticText(_("Save"))
1237 self["url"] = Label()
1239 self._currentPageUrl = currentUrl
1240 if self._currentPageUrl is None:
1241 self._currentPageUrl = ''
1242 self._startPageUrl = None
1243 self._keymapType = None
1244 self.makeMenuEntry()
1245 self.onLayoutFinish.append(self.layoutFinished)
1247 def layoutFinished(self):
1248 self.setTitle(_('Preference'))
1250 def updateStartPageUrl(self):
1251 if self.menuItemStartpage.value == "startpage":
1252 self["url"].setText(self._startPageUrl)
1253 elif self.menuItemStartpage.value == "current":
1254 self["url"].setText(self._currentPageUrl)
1255 elif self.menuItemStartpage.value == "direct":
1256 self["url"].setText('')
1259 url = self["url"].getText()
1261 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1264 if url.find('/usr/local/manual') > 0:
1266 self._keymapType = self.menuItemKeyboardLayout.value
1267 OperaBrowserSetting().setData(url, mode, self._keymapType)
1268 command_util = getCommandUtil()
1269 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1276 def _cb_directInputUrl(data):
1277 if strIsEmpty(data):
1279 self["url"].setText(data)
1280 if self.menuItemStartpage.value == "direct":
1281 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1284 ConfigListScreen.keyLeft(self)
1285 self.updateStartPageUrl()
1288 ConfigListScreen.keyRight(self)
1289 self.updateStartPageUrl()
1291 def getKeymapTypeList(self):
1293 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1294 filesplit = f.split('.')
1295 if len(filesplit) < 2:
1297 types.append((filesplit[1], filesplit[1]))
1301 def makeMenuEntry(self):
1303 l.append(("startpage", _("Start Page")))
1304 if not strIsEmpty(self._currentPageUrl):
1305 l.append(("current", _("Current Page")))
1306 l.append(("direct", _("Direct Input")))
1307 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1308 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1310 kl = self.getKeymapTypeList()
1313 d = OperaBrowserSetting().getData()
1314 self._startPageUrl = d['start']
1315 self._keymapType = d['keymap']
1317 except: self._startPageUrl = 'http://vuplus.com'
1318 self.updateStartPageUrl()
1320 if self._keymapType is None or len(self._keymapType) == 0:
1321 self._keymapType = "us-rc"
1322 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1323 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1324 self.resetMenuList()
1326 def resetMenuList(self):
1328 self.menulist.append(self.menuEntryStartpage)
1329 self.menulist.append(self.menuEntryKeyboardLayout)
1331 self["config"].list = self.menulist
1332 self["config"].l.setList(self.menulist)
1334 class BookmarkEditWindow(ConfigListScreen, Screen):
1335 CATEGORY,BOOKMARK = 0,1
1337 <screen position="center,center" size="600,140" title="Bookmark Edit">
1338 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1340 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1341 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1343 <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" />
1344 <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" />
1346 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1350 def __init__(self, session, _mode, _type, _data, _bm):
1354 self.mSession = session
1355 self.mBookmarkManager = _bm
1357 if _data is not None:
1360 Screen.__init__(self, session)
1363 ConfigListScreen.__init__(self, self.menulist)
1365 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1366 "ok" : self.keyGreen,
1367 "green" : self.keyGreen,
1368 "red" : self.keyRed,
1369 "cancel" : self.keyRed,
1372 self["VKeyIcon"] = Pixmap()
1373 self["key_red"] = StaticText(_("Cancel"))
1374 self["key_green"] = StaticText(_("Save"))
1376 self.menuItemTitle = None
1377 self.menuItemUrl = None
1378 self.menuItemName = None
1380 self.menuEntryName = None
1381 self.menuEntryTitle = None
1382 self.menuEntryUrl = None
1384 self.makeConfigList()
1385 self.onLayoutFinish.append(self.layoutFinished)
1387 def layoutFinished(self):
1388 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1390 def selectedItem(self):
1391 currentPosition = self["config"].getCurrent()
1392 if self.mType == BookmarkEditWindow.CATEGORY:
1393 return (_("Name"), self.menuItemName)
1395 if currentPosition == self.menuEntryTitle:
1396 return (_("Title"), self.menuItemTitle)
1397 elif currentPosition == self.menuEntryUrl:
1398 return (_("Url"), self.menuItemUrl)
1401 def showMessageBox(self, text):
1402 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1403 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1406 def showVKeyWindow(self, data=None):
1409 selected = self.selectedItem()
1410 if selected is not None:
1411 itemValue = selected[1].value
1412 if strIsEmpty(itemValue):
1414 itemTitle = selected[0]
1416 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1418 def cbVKeyWindow(self, data=None):
1419 if data is not None:
1420 selected = self.selectedItem()
1421 if selected is not None:
1422 selected[1].setValue(data)
1425 if self.mType == BookmarkEditWindow.CATEGORY:
1426 if self.mMode == _('Add'):
1427 categoryName = self.menuItemName.value
1428 if strIsEmpty(categoryName):
1429 return self.showMessageBox(_("Category Name"))
1430 self.mBookmarkManager.addCategory(categoryName)
1432 if strIsEmpty(self.menuItemName.value):
1433 return self.showMessageBox(_("Category Name"))
1434 self.mData.mName = self.menuItemName.value
1435 self.mBookmarkManager.updateCategory(self.mData)
1437 if self.mMode == _('Add'):
1438 bookmarkTitle = self.menuItemTitle.value
1439 bookmarkUrl = self.menuItemUrl.value
1440 if strIsEmpty(bookmarkTitle):
1441 self["config"].setCurrentIndex(0)
1442 return self.showMessageBox(_("Bookmark Title"))
1443 if strIsEmpty(bookmarkUrl):
1444 self["config"].setCurrentIndex(1)
1445 return self.showMessageBox(_("Bookmark URL"))
1446 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1448 if strIsEmpty(self.menuItemTitle.value):
1449 self["config"].setCurrentIndex(0)
1450 return self.showMessageBox(_("Bookmark Title"))
1451 if strIsEmpty(self.menuItemUrl.value):
1452 self["config"].setCurrentIndex(1)
1453 return self.showMessageBox(_("Bookmark URL"))
1454 self.mData.mTitle = self.menuItemTitle.value
1455 self.mData.mUrl = self.menuItemUrl.value
1456 self.mBookmarkManager.updateBookmark(self.mData)
1460 if not self.saveData():
1466 ConfigListScreen.keyLeft(self)
1468 ConfigListScreen.keyRight(self)
1469 def makeConfigList(self):
1472 if self.mType == BookmarkEditWindow.CATEGORY:
1473 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1475 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1477 self.menulist.append(self.menuEntryName)
1479 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1480 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1482 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1483 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1485 self.menulist.append(self.menuEntryTitle)
1486 self.menulist.append(self.menuEntryUrl)
1488 self["config"].list = self.menulist
1489 self["config"].l.setList(self.menulist)
1491 class OperaBrowserBookmarkWindow(Screen):
1493 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1494 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1496 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1497 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1499 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1500 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1501 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1502 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1504 <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" />
1505 <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" />
1506 <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" />
1507 <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" />
1511 def __init__(self, _session, _url=None, _title=None):
1513 self.mTitle = _title
1514 self.mBookmarkManager = BookmarkManager.getInstance()
1515 self.mSession = _session
1516 Screen.__init__(self, _session)
1517 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1519 "cancel": self.keyCancel,
1520 "red" : self.keyRed,
1521 "green" : self.keyGreen,
1522 "yellow": self.keyYellow,
1523 "blue" : self.keyBlue,
1524 "0" : self.keyNumber,
1527 self["key_red"] = StaticText(_("Exit"))
1528 self["key_green"] = StaticText(_("Add"))
1529 self["key_yellow"] = StaticText(_("Edit"))
1530 self["key_blue"] = StaticText(_("Delete"))
1531 self["key_0"] = StaticText(_("Set as Startpage"))
1533 self.mBookmarkList = self.setBookmarkList()
1534 self["bookmarklist"] = MenuList(self.mBookmarkList)
1536 self.onLayoutFinish.append(self.layoutFinished)
1538 def layoutFinished(self):
1539 self.setTitle(_('Bookmark'))
1541 def setBookmarkList(self):
1543 #self.mBookmarkManager.dump()
1544 cd = self.mBookmarkManager.getBookmarkRoot()
1545 for ck in cd.iterkeys():
1546 l.append(('# ' + cd[ck].mName, cd[ck]))
1547 bd = cd[ck].mBookmarks
1548 for bk in bd.iterkeys():
1549 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1551 def updateBookmarkList(self):
1552 self.mBookmarkList = self.setBookmarkList()
1553 self["bookmarklist"].setList(self.mBookmarkList)
1554 def cbEditWindow(self, ret=False):
1557 self.updateBookmarkList()
1558 def getParentCategory(self):
1559 idx = self["bookmarklist"].getSelectedIndex()
1562 data = self.mBookmarkList[idx][0].strip()
1564 return self.mBookmarkList[idx][1]
1568 def isCategoryItem(self):
1570 head = self["bookmarklist"].getCurrent()[0].strip()
1575 def keyNumber(self):
1576 data = self["bookmarklist"].getCurrent()[1]
1577 if strIsEmpty(data.mUrl):
1578 msg = _("Invalid URL. Please check again!!")
1579 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1581 def cbSetStartpage(ret=None):
1582 if ret is None: return
1584 data = self["bookmarklist"].getCurrent()[1]
1585 OperaBrowserSetting().setData(data.mUrl, data.mType)
1586 msg = _("Do you want to set selected url to the Startpage?")
1587 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1594 parent = self.getParentCategory()
1597 if strIsEmpty(self.mTitle):
1599 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1601 msg = _("Current page is already exist.")
1602 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1603 self.cbEditWindow(True)
1605 parent = self.getParentCategory()
1608 b = BookmarkData(0, '', '', parent.mId, 0)
1609 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1611 c = CategoryData(0, '')
1612 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1613 if strIsEmpty(self.mUrl):
1614 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1615 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1616 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1617 def keyYellow(self):
1618 data = self["bookmarklist"].getCurrent()[1]
1619 if self.isCategoryItem():
1620 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1621 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1623 def cbBlue(ret=None):
1625 data = self["bookmarklist"].getCurrent()[1]
1626 if self.isCategoryItem():
1627 self.mBookmarkManager.deleteCategory(data.mId)
1628 else: self.mBookmarkManager.deleteBookmark(data.mId)
1629 self.updateBookmarkList()
1630 if self.isCategoryItem():
1631 msg = _("Do you want to delete the category and the bookmarks?")
1632 else: msg = _("Do you want to delete the bookmark?")
1633 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1635 if self.isCategoryItem(): return
1637 data = self["bookmarklist"].getCurrent()[1]
1638 url = data.mUrl.strip()
1640 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1644 lang = language.getLanguage()
1645 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1646 url = '/usr/local/manual/ru_RU/main.html'
1647 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1648 url = '/usr/local/manual/de_DE/main.html'
1649 self.close((url, mode))
1652 def keyCancel(self):
1655 class BrowserHelpWindow(Screen, HelpableScreen):
1656 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1658 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1659 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1660 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1661 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1662 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1664 <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" />
1665 <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" />
1666 <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" />
1667 <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" />
1670 def __init__(self, session):
1671 Screen.__init__(self, session)
1672 HelpableScreen.__init__(self)
1674 self["key_red"] = StaticText(_("Exit"))
1675 self["key_green"] = StaticText(_("Global"))
1676 self["key_yellow"] = StaticText(_("Mouse"))
1677 self["key_blue"] = StaticText(_("Keyboard"))
1679 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1681 "cancel": self.keyRed,
1682 "red" : self.keyRed,
1683 "green" : self.keyGreen,
1684 "yellow": self.keyYellow,
1685 "blue" : self.keyBlue,
1688 self.showHelpTimer = eTimer()
1689 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1690 self.showHelpTimer.start(500)
1692 self.onLayoutFinish.append(self.layoutFinished)
1694 def layoutFinished(self):
1695 self.setTitle(_('Browser Help'))
1697 def cbShowHelpTimerClosed(self):
1698 self.showHelpTimer.stop()
1699 self.setHelpModeActions(self.MODE_GLOBAL)
1701 def setHelpModeActions(self, _mode=0):
1703 if _mode == self.MODE_GLOBAL:
1704 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1705 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1707 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1708 "menu" : (self.keyPass, _("Show the Menu window.")),
1710 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1711 "green" : (self.keyPass, _("Enter Key")),
1712 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1713 "blue" : (self.keyPass, _("Backspace Key")),
1715 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1716 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1719 elif _mode == self.MODE_MOUSE:
1720 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1721 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1722 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1723 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1724 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1726 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1727 "ok" : (self.keyPass, _("Left Mouse Button")),
1729 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1730 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1731 "nextService" : (self.keyPass, _("Left Key")),
1732 "prevService" : (self.keyPass, _("Right Key")),
1734 elif _mode == self.MODE_KEYBOARD:
1735 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1736 "up" : (self.keyPass, _("Up Key")),
1737 "down" : (self.keyPass, _("Down Key")),
1738 "left" : (self.keyPass, _("Left Key")),
1739 "right" : (self.keyPass, _("Right Key")),
1741 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1742 "ok" : (self.keyPass, _("Enter Key")),
1744 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1745 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1746 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1747 "nextService" : (self.keyPass, _("Go to previous page.")),
1748 "prevService" : (self.keyPass, _("Go to next page.")),
1760 self.setHelpModeActions(self.MODE_GLOBAL)
1761 def keyYellow(self):
1762 self.setHelpModeActions(self.MODE_MOUSE)
1764 self.setHelpModeActions(self.MODE_KEYBOARD)
1766 class OperaBrowser(Screen):
1767 MENUBAR_ITEM_WIDTH = 150
1768 MENUBAR_ITEM_HEIGHT = 30
1769 SUBMENULIST_WIDTH = 200
1770 SUBMENULIST_HEIGHT = 25
1771 SUBMENULIST_NEXT = 2
1773 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1774 # menulist->size->x : SUBMENULIST_WIDTH
1775 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1776 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1777 # submenulist->size->x : SUBMENULIST_WIDTH
1779 size = getDesktop(0).size()
1780 WIDTH = int(size.width())
1781 HEIGHT = int(size.height())
1783 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1784 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1785 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1786 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1787 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1788 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1789 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1790 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1792 """ % { 'width' :WIDTH,
1794 'bottom_pos_y' :HEIGHT-80,
1795 'bottom_size_x' :WIDTH }
1799 def __init__(self, session, url=None, isWebAppMode=False):
1800 Screen.__init__(self, session)
1801 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1802 "cancel" : self.keyCancel
1804 ,"left" : self.keyLeft
1805 ,"right" : self.keyRight
1807 ,"down" : self.keyDown
1808 ,"menu" : self.keyMenu
1811 self.UpdateLanguageCB()
1813 self._terminatedBrowser = True
1814 self._enableKeyEvent = True
1815 self._currentPageUrl = None
1816 self._currentPageTitle = None
1817 self.menubarCurrentIndex = 0
1818 self.lvMenuItems = []
1819 self.lvSubMenuItems = []
1821 self["topArea"] = Label()
1822 self["bottomArea"] = Label()
1824 self["menuitemFile"] = MultiColorLabel()# modify menu
1825 self["menuitemTool"] = MultiColorLabel()
1826 self["menuitemHelp"] = MultiColorLabel()
1828 self["menulist"] = MenuList(self.setListOnView())
1829 self["submenulist"] = MenuList(self.setSubListOnView())
1831 self.toggleMainScreenFlag = True
1832 self.toggleListViewFlag = False
1833 self.toggleSubListViewFlag = False
1834 self.currentListView = self["menulist"]
1836 self.onLayoutFinish.append(self.layoutFinished)
1838 self._onCloseTimer = eTimer()
1839 self._onCloseTimer.callback.append(self._cb_onClose)
1842 self.paramIsWebAppMode = isWebAppMode
1843 language.addCallback(self.UpdateLanguageCB)
1845 def UpdateLanguageCB(self):
1847 self.MENUITEMS_LIST = [
1848 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1849 [(_('Bookmark'), None), (_('Preference'), None)],
1850 [(_('About'), None), (_('Help'), None)]]
1851 self.COMMAND_MAP = {}
1852 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1853 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1854 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1855 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1856 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1857 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1858 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1859 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1860 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1862 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1863 rcmouse_path = "/proc/stb/fp/mouse"
1864 if os.path.exists(rcmouse_path):
1865 os.system("echo %d > %s" % (mode, rcmouse_path))
1867 def layoutFinished(self):
1868 self["menuitemFile"].setText(_("File"))# modify menu
1869 self["menuitemTool"].setText(_("Tools"))
1870 self["menuitemHelp"].setText(_("Help"))
1872 self["menulist"].hide()
1873 self["submenulist"].hide()
1875 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1876 self.setTitle(_("BrowserMain"))
1877 self.selectMenuitem()
1879 if self.paramUrl is not None:
1881 if self.paramIsWebAppMode:
1882 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1883 else: self.cbUrlText(data=self.paramUrl, mode=1)
1885 def selectMenuitem(self):
1886 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1887 self["menuitemFile"].setForegroundColorNum(0)
1888 self["menuitemTool"].setForegroundColorNum(0)
1889 self["menuitemHelp"].setForegroundColorNum(0)
1890 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1892 def popupCloseAll(self):
1898 def setListOnView(self):
1899 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1900 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1901 l = [(_('Return'), None)]
1902 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1903 return self.lvMenuItems
1905 def setSubListOnView(self):
1906 self.lvSubMenuItems = []
1907 xl = self["menulist"].getCurrent()[1]
1908 if xl is None: return []
1910 self.lvSubMenuItems.append((x,None))
1911 return self.lvSubMenuItems
1913 def toggleMainScreen(self):
1914 if not self.toggleMainScreenFlag:
1917 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1919 def toggleListView(self):
1920 if not self.toggleListViewFlag:
1921 self["menulist"].show()
1922 else: self["menulist"].hide()
1923 self.toggleListViewFlag = not self.toggleListViewFlag
1925 def toggleSubListView(self):
1926 if not self.toggleSubListViewFlag:
1927 self["submenulist"].show()
1928 else: self["submenulist"].hide()
1929 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1931 def setCurrentListView(self, listViewIdx):
1932 if listViewIdx == 0:
1933 self.currentListView = None
1934 elif listViewIdx == 1:
1935 self.currentListView = self["menulist"]
1936 elif listViewIdx == 2:
1937 self.currentListView = self["submenulist"]
1939 def _cb_onClose(self):
1940 self._onCloseTimer.stop()
1941 command_server = getCommandServer()
1943 if self._on_close_window in command_server.onHbbTVCloseCB:
1944 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1945 except Exception, ErrMsg: pass
1947 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1948 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1949 except Exception, ErrMsg: pass
1950 self._on_setPageTitle(_('Opera Browser'))
1951 self.enableRCMouse(False)
1952 self.toggleMainScreen()
1954 fbClass.getInstance().unlock()
1955 eRCInput.getInstance().unlock()
1956 self._terminatedBrowser = True
1957 self._enableKeyEvent = True
1958 #if not self.toggleListViewFlag:
1961 self._currentPageUrl = ''
1962 if self.paramUrl is not None:
1968 def _on_setPageTitle(self, title=None):
1969 print "Title :",title
1972 self.setTitle(title)
1974 def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
1976 if not _g_helper._is_browser_running():
1978 print "Inputed Url :", data, mode
1979 if strIsEmpty(data):
1982 command_server = getCommandServer()
1983 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1984 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1985 if self._on_close_window not in command_server.onHbbTVCloseCB:
1986 command_server.onHbbTVCloseCB.append(self._on_close_window)
1987 self.toggleMainScreen()
1988 self.enableRCMouse(True)
1990 fbClass.getInstance().lock()
1991 eRCInput.getInstance().lock()
1993 #setResolution(1280, 720)
1995 command_util = getCommandUtil()
1996 command_util.sendCommand(opcode, data, mode)
1997 self._terminatedBrowser = False
1998 self._enableKeyEvent = False
2000 def _on_close_window(self):
2001 self._onCloseTimer.start(1000)
2003 def _cb_bookmarkWindowClosed(self, data=None):
2008 if not _g_helper._is_browser_running():
2009 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2010 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2012 self.cbUrlText(url, mode)
2014 def _cmd_on_OpenUrl(self):
2016 if not _g_helper._is_browser_running():
2017 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2018 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2020 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2021 def _cmd_on_About(self):
2022 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2023 def _cmd_on_Exit(self):
2025 def _cb_cmdOnStartSTop(self):
2027 def _cmd_on_StartStop(self):
2029 if _g_helper is None:
2031 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2033 def _cmd_on_Bookmark(self):
2034 url = self._currentPageUrl
2037 title = self._currentPageTitle
2040 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2041 def _cmd_on_Preference(self):
2042 url = self._currentPageUrl
2045 self.session.open(OperaBrowserPreferenceWindow, url)
2046 def _cmd_on_OpenStartpage(self):
2048 if not _g_helper._is_browser_running():
2049 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2050 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2053 start = 'http://vuplus.com'
2055 d = OperaBrowserSetting().getData()
2059 self.cbUrlText(start, mode)
2060 def _cmd_on_ReturnToBrowser(self):
2063 def _cmd_on_Help(self):
2064 self.session.open(BrowserHelpWindow)
2066 def doCommand(self, command):
2068 self.COMMAND_MAP[command]()
2069 except Exception, ErrMsg: print ErrMsg
2072 if not self.toggleMainScreenFlag:
2075 if not self.toggleListViewFlag:
2078 if self.currentListView.getCurrent()[1] is None:
2079 self.doCommand(self.currentListView.getCurrent()[0])
2080 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2084 def updateSelectedMenuitem(self, status):
2085 if self.menubarCurrentIndex == 0 and status < 0:
2086 self.menubarCurrentIndex = 2 # modify menu
2087 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2088 self.menubarCurrentIndex = 0
2089 else: self.menubarCurrentIndex += status
2090 self.selectMenuitem()
2093 if not self.toggleMainScreenFlag:
2095 if not self.toggleListViewFlag:
2096 self.updateSelectedMenuitem(-1)
2098 if self.toggleSubListViewFlag:
2099 self.setCurrentListView(1)
2100 self.toggleSubListView()
2102 #if self.currentListView.getSelectedIndex():
2103 self.currentListView.pageUp()
2109 if not self.toggleMainScreenFlag:
2111 if not self.toggleListViewFlag:
2112 self.updateSelectedMenuitem(1)
2114 if self.currentListView is None:
2116 if self.currentListView.getCurrent()[1] is not None:
2117 parentSelectedIndex = self.currentListView.getSelectedIndex()
2118 self.setCurrentListView(2)
2119 self.currentListView.setList(self.setSubListOnView())
2120 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2121 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))
2122 self.toggleSubListView()
2124 self.currentListView.pageUp()
2130 if not self.toggleMainScreenFlag:
2132 if self.currentListView is None:
2134 if not self.toggleListViewFlag:
2135 self.currentListView.setList(self.setListOnView())
2136 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2137 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2138 self.toggleListView()
2140 self.currentListView.down()
2143 if not self.toggleMainScreenFlag:
2145 if self.currentListView is None:
2147 if self.currentListView == self["menulist"]:
2148 if self.currentListView.getSelectedIndex() == 0:
2149 self.toggleListView()
2151 self.currentListView.up()
2153 def keyCancel(self):
2154 if not self._terminatedBrowser:
2155 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2156 fbClass.getInstance().lock()
2157 eRCInput.getInstance().lock()
2158 #setResolution(1280, 720)
2159 if self.toggleListViewFlag:
2160 self.toggleMainScreen()
2161 self._currentPageUrl = None
2162 self._currentPageTitle = None
2163 command_util = getCommandUtil()
2164 command_util.sendCommand('OP_BROWSER_MENU_RES')
2169 self.toggleMainScreen()
2171 def setCurrentPageUrl(self, url, title=None):
2172 self._currentPageUrl = url
2175 if idx > 10: idx = 10
2177 self._currentPageTitle = title
2178 print self._currentPageUrl
2179 self.toggleMainScreen()
2183 def hideSubmenu(self):
2184 self.currentListView.pageUp()
2187 config.plugins.youtubetv = ConfigSubsection()
2188 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2189 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2190 class YoutubeTVWindow(Screen, HelpableScreen):
2192 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2193 <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2194 <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2195 <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2196 <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2197 <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2198 <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" />
2199 <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" />
2202 def __init__(self, session):
2203 Screen.__init__(self, session)
2204 HelpableScreen.__init__(self)
2206 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2207 "cancel": self.keyCancel,
2208 "red" : self.keyCancel,
2209 "green" : self.keyGreen,
2210 "yellow": self.keyYellow,
2213 self["key_green"] = StaticText(_("Start"))
2214 self["key_yellow"] = StaticText(_("Help"))
2216 self["infomation"] = Label()
2217 self["startdesc"] = Label()
2218 self["helpdesc"] = Label()
2220 self.onLayoutFinish.append(self.layoutFinished)
2222 def layoutFinished(self):
2223 self.setTitle(_('Start YouTube TV'))
2224 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2225 self["startdesc" ].setText(_("* Start YouTube TV"))
2226 self["helpdesc" ].setText(_("* RC Help"))
2228 def setHelpModeActions(self):
2230 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2231 "ok" : (self.keyPass, _("Play ther selected the video")),
2232 "cancel": (self.keyPass, _("Exit the YouTube TV")),
2234 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2235 "pageUp" : (self.keyPass, _("Move up")),
2236 "pageDown" : (self.keyPass, _("Move down")),
2237 "prevEvent" : (self.keyPass, _("Move left")),
2238 "nextEvent" : (self.keyPass, _("Move right")),
2240 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2241 "info" : (self.keyPass, _("Search a video")),
2242 "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2243 "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2245 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2246 "play" : (self.keyPass, _("Play current video")),
2247 "pause" : (self.keyPass, _("Pause current video")),
2248 "stop" : (self.keyPass, _("Stop current video")),
2250 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2251 "red" : (self.keyPass, _("Back")),
2257 def keyCancel(self):
2258 config.plugins.youtubetv.showhelp.cancel()
2261 config.plugins.youtubetv.showhelp.save()
2262 config.plugins.youtubetv.save()
2263 config.plugins.save()
2265 def keyYellow(self):
2266 self.setHelpModeActions()
2268 if config.plugins.youtubetv.showhelp.value == True :
2269 config.plugins.youtubetv.showhelp.setValue(False)
2270 else: config.plugins.youtubetv.showhelp.setValue(True)
2272 class YoutubeTVSettings(ConfigListScreen, Screen):
2274 <screen position="center,center" size="600,140" title="YouTube TV Settings">
2275 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2277 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2278 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2280 <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" />
2281 <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" />
2284 def __init__(self, session):
2285 self.session = session
2286 Screen.__init__(self, session)
2289 ConfigListScreen.__init__(self, self.menulist)
2291 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2292 "ok" : self.keyGreen,
2293 "green" : self.keyGreen,
2294 "red" : self.keyRed,
2295 "cancel" : self.keyRed,
2298 self["key_red"] = StaticText(_("Cancel"))
2299 self["key_green"] = StaticText(_("Save"))
2301 self.makeConfigList()
2302 self.onLayoutFinish.append(self.layoutFinished)
2304 def layoutFinished(self):
2305 self.setTitle(_('YouTube TV Settings'))
2308 config.plugins.youtubetv.showhelp.save()
2309 config.plugins.youtubetv.uri.save()
2310 config.plugins.youtubetv.save()
2311 config.plugins.save()
2314 config.plugins.youtubetv.showhelp.cancel()
2315 config.plugins.youtubetv.uri.cancel()
2319 ConfigListScreen.keyLeft(self)
2322 ConfigListScreen.keyRight(self)
2324 def makeConfigList(self):
2326 entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2327 entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Stater again"), config.plugins.youtubetv.showhelp)
2328 self.menulist.append(entryUri)
2329 self.menulist.append(entryShowHelp)
2331 self["config"].list = self.menulist
2332 self["config"].l.setList(self.menulist)
2334 def auto_start_main(reason, **kwargs):
2336 command_server = getCommandServer()
2337 command_server.stop()
2339 from Screens.HelpMenu import HelpableScreen
2340 def session_start_main(session, reason, **kwargs):
2341 fbClass.getInstance().unlock()
2342 eRCInput.getInstance().unlock()
2344 from enigma import getDesktop
2345 desktopSize = getDesktop(0).size()
2346 setDefaultResolution(desktopSize.width(), desktopSize.height())
2349 _g_helper = session.open(HbbTVHelper)
2351 HelpableScreen.__init__ = HelpableScreen__init__
2352 HelpableScreen.session = session
2354 def HelpableScreen__init__(self):
2355 if isinstance(self, HelpableScreen):
2356 HelpableScreen.showManual = showManual
2358 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2359 "help_b" : self.showHelp,
2360 "help_l" : self.showManual,
2363 _g_clearBrowserDataTimer = eTimer()
2364 def showManual(self):
2365 if not os.path.exists('/usr/local/manual'):
2368 url = 'file:///usr/local/manual/main.html'
2369 lang = language.getLanguage()
2370 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2371 url = 'file:///usr/local/manual/ru_RU/main.html'
2372 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2373 url = 'file:///usr/local/manual/de_DE/main.html'
2376 _g_clearBrowserDataTimer.stop()
2377 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2379 setPluginBrowser(None)
2380 def clearBrowserData():
2381 _g_clearBrowserDataTimer.callback.append(_do_clean)
2382 _g_clearBrowserDataTimer.start(50)
2383 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2385 _g_backupSession = None
2386 def showYoutubeTV(session, **kwargs):
2388 _g_clearBrowserDataTimer.stop()
2389 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2391 setPluginBrowser(None)
2392 global _g_backupSession
2394 service = getBeforeService()
2395 if service is not None:
2396 _g_backupSession.nav.playService(eServiceReference(service))
2397 _g_backupSession = None
2398 def clearBrowserData():
2399 _g_clearBrowserDataTimer.callback.append(_do_clean)
2400 _g_clearBrowserDataTimer.start(50)
2401 def cbYoutubeTVClose(ret):
2403 global _g_backupSession
2404 _g_backupSession = session
2405 service = session.nav.getCurrentlyPlayingServiceReference()
2406 if service is not None:
2407 setBeforeService(service.toString())
2408 session.nav.stopService()
2409 else: setBeforeService(service)
2410 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2411 if config.plugins.youtubetv.showhelp.value == True:
2412 cbYoutubeTVClose(True)
2413 else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2415 def youtube_setting_main(session, **kwargs):
2416 session.open(YoutubeTVSettings)
2418 def start_menu_main(menuid, **kwargs):
2419 if menuid == "mainmenu":
2420 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2423 def plugin_start_main(session, **kwargs):
2424 #session.open(OperaBrowser)
2426 _g_clearBrowserDataTimer.stop()
2427 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2429 setPluginBrowser(None)
2430 def clearBrowserData():
2431 _g_clearBrowserDataTimer.callback.append(_do_clean)
2432 _g_clearBrowserDataTimer.start(50)
2433 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2435 def plugin_extension_start_application(session, **kwargs):
2437 if _g_helper is None:
2439 _g_helper.showApplicationSelectionBox()
2441 def plugin_extension_browser_config(session, **kwargs):
2443 if _g_helper is None:
2445 _g_helper.showBrowserConfigBox()
2447 def Plugins(path, **kwargs):
2449 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2450 l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2451 l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2452 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2453 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2454 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2455 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))