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
482 self._max_volume = -1
483 self._soft_volume = -1
485 def _handle_dump(self, handle, opcode, data=None):
489 print " - opcode : ", self.opcode.what(opcode)
491 print " - data : ", data
493 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
494 opcode, params, reserved = None, None, 0
495 self._on_close_cb = onCloseCB
496 self._on_set_title_cb = onSetPageTitleCB
498 datas = self.doUnpack(data)
499 except Exception, ErrMsg:
500 print "Unpacking packet ERR :", ErrMsg
501 params = 'fail to unpack packet!!'
502 opcode = self.opcode.get("OP_UNKNOWN")
503 return self.doPack(opcode, params)
507 self.opcode.what(opcode)
510 #print self.handle_map[opcode]
511 (reserved, params) = self.handle_map[opcode](opcode, params)
512 except Exception, ErrMsg:
513 print "Handling packet ERR :", ErrMsg
514 params = 'fail to handle packet!!'
515 opcode = self.opcode.get("OP_UNKNOWN")
516 return self.doPack(opcode, params)
517 self._on_close_cb = None
518 self._on_set_title_cb = None
519 return self.doPack(opcode, params, reserved)
521 def _cb_handleVideobackendEnable(self, opcode, data):
522 self._handle_dump(self._cb_handleVideobackendEnable, opcode, data)
523 service = self._session.nav.getCurrentlyPlayingServiceReference()
524 setBeforeService(service)
525 self._session.nav.stopService()
528 def _cb_handleVideobackendDisable(self, opcode, data):
529 self._handle_dump(self._cb_handleVideobackendDisable, opcode, data)
530 before_service = getBeforeService()
531 if before_service is not None:
532 self._session.nav.playService(before_service)
535 def _cb_handleHbbTVChangeChannel(self, opcode, data):
536 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
538 if _g_helper is None:
540 dataItems = data.split(":")
543 if not _g_helper.doChangeChannel(sid, tsid):
547 def _cb_handleBrowserMenuReq(self, opcode, data):
548 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
550 fbClass.getInstance().unlock()
551 eRCInput.getInstance().unlock()
552 browser = getPluginBrowser()
553 if browser is not None:
554 browser.setCurrentPageUrl(data, self._curren_title)
557 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
558 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
559 def _cb_PasteRefocusVirtualKeyboard():
560 self._timer_paste_vkbd.stop()
561 command_util = getCommandUtil()
562 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
564 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
566 def _cb_PasteKeyVirtualKeyboard():
567 self._timer_paste_vkbd.stop()
568 command_util = getCommandUtil()
569 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
571 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
573 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
574 self._timer_paste_vkbd.start(100)
575 def _cb_PasteMouseVirtualKeyboard():
576 self._timer_paste_vkbd.stop()
577 command_util = getCommandUtil()
578 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
580 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
582 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
584 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
585 #self._timer_paste_vkbd.start(1000)
586 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
587 self._timer_paste_vkbd.start(50)
590 def _cb_virtualKeyboardClosed(self, data=None):
591 fbClass.getInstance().lock()
592 eRCInput.getInstance().lock()
593 #setResolution(1280, 720)
594 command_util = getCommandUtil()
595 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
597 def _cb_handleShowVirtualKeyboard(self, opcode, data):
598 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
600 fbClass.getInstance().unlock()
601 eRCInput.getInstance().unlock()
602 if data == 0 or strIsEmpty(data):
604 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
607 def _cb_handleVODSeekCtrl(self, opcode, data):
608 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
609 headLen = struct.calcsize('!I')
610 unpackedData = struct.unpack('!I', data[:headLen])
611 seekTime = unpackedData[0]
612 service = self._session.nav.getCurrentService()
613 seekable = service.seek()
614 if seekable is None or not seekable.isCurrentlySeekable():
615 raise Exception("This stream is not support manual seek.")
617 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
620 def _cb_handleHbbTVRetryOpen(self, opcode, data):
621 def _cb_HbbTVRetryOpenURL():
622 self._timer_retry_open.stop()
623 if self._retry_open_url is not None:
624 command_util = getCommandUtil()
625 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
626 self._retry_open_url = None
628 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
630 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
631 headLen = struct.calcsize('!I')
632 unpackedData = struct.unpack('!I', data[:headLen])
633 delayTime = unpackedData[0]
634 restartUrl = data[headLen:]
636 self._retry_open_url = restartUrl.strip()
637 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
638 self._timer_retry_open.start(delayTime*1000)
641 def _cb_handleSystemNotufyMyPID(self, opcode, data):
642 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
645 def _cb_handleSystemOutOfMemory(self, opcode, data):
646 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
650 def _cb_handleVODSpeedCtrl(self, opcode, data):
651 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
652 headLen = struct.calcsize('!I')
653 unpackedData = struct.unpack('!I', data[:headLen])
654 playSpeed = unpackedData[0]
655 service = self._session.nav.getCurrentService()
656 pauseable = service.pause()
659 if pauseable.setFastForward(playSpeed) == -1:
660 pauseable.setFastForward(1)
661 raise Exception("This stream is not support trick play.")
664 def SetVolume(self, volume):
665 if self._max_volume < 0:
666 self._max_volume = VolumeControl.instance.volctrl.getVolume()
668 self._max_volume += volume
669 if self._max_volume > 100:
670 self._max_volume = 100
671 elif self._max_volume < 0:
674 if self._soft_volume > 0:
675 v = int((self._max_volume * self._soft_volume) / 100)
676 VolumeControl.instance.volctrl.setVolume(v, v)
677 else: VolumeControl.instance.volctrl.setVolume(self._max_volume, self._max_volume)
679 def _cb_handleDVBAppVolUp(self, opcode, data):
680 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
684 def _cb_handleDVBAppVolDown(self, opcode, data):
685 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
689 def _cb_handleDVBAppSetVol(self, opcode, data):
690 self._handle_dump(self._cb_handleDVBAppSetVol, opcode, data)
691 if self._max_volume < 0:
692 self._max_volume = VolumeControl.instance.volctrl.getVolume()
693 self._soft_volume = int(data)
696 if self._soft_volume > 0 and self._max_volume > 0:
697 v = int((self._max_volume * self._soft_volume) / 100)
698 VolumeControl.instance.volctrl.setVolume(v, v)
701 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
702 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
703 (sid, onid, tsid, name, orgid) = getChannelInfos()
705 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
707 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
708 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
709 (sid, onid, tsid, name, orgid) = getChannelInfos()
711 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
713 def _cb_handleGetChannelInfoList(self, opcode, data):
714 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
715 (sid, onid, tsid, name, orgid) = getChannelInfos()
717 channel_list_size = 1
718 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
720 def _cb_handleSetPageTitle(self, opcode, data):
721 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
722 if data.startswith('file://') or data.startswith('http://'):
724 if self._on_set_title_cb is not None:
725 for x in self._on_set_title_cb:
728 self._curren_title = data
729 except Exception, ErrMsg:
730 if x in self._on_set_title_cb:
731 self._on_set_title_cb.remove(x)
734 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
735 self._timer_retry_open.stop()
737 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
739 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
741 if self._on_close_cb:
742 for x in self._on_close_cb:
745 except Exception, ErrMsg:
746 if x in self._on_close_cb:
747 self._on_close_cb.remove(x)
749 command_util = getCommandUtil()
750 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
752 before_service = getBeforeService()
753 if before_service is not None:
754 self._session.nav.playService(before_service)
760 def _cb_handleVODPlayerURI(self, opcode, data):
762 hl = struct.calcsize('!II')
763 datas = struct.unpack('!II', data[:hl])
765 vodUri = data[hl:hl+uriLength]
766 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
767 self._vod_uri = vodUri
770 def doStop(self, restoreBeforeService=True, needStop=True):
772 self._session.nav.stopService()
773 if self._vod_service is not None and restoreBeforeService:
774 before_service = getBeforeService()
775 self._session.nav.playService(before_service)
777 self._vod_service = None
782 def doRetryOpen(self, url):
786 self._vod_service = None
788 #print "Try to open vod [%d] : %s" % (ii, url)
789 print "Try to open vod"
790 self._vod_service = eServiceReference(4097, 0, url)
791 self._session.nav.playService(self._vod_service)
792 if self._vod_service is not None:
794 except Exception, ErrMsg:
795 print "OpenVOD ERR :", ErrMsg
799 def _cb_handleVODPlayerPlay(self, opcode, data):
800 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
801 self.doStop(restoreBeforeService=False)
802 if self.doRetryOpen(url=self._vod_uri) == False:
806 def _cb_handleVODPlayerStop(self, opcode, data):
807 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
811 def _cb_handleVODPlayerPlayPause(self, opcode, data):
812 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
813 service = self._session.nav.getCurrentService()
816 servicePause = service.pause()
818 servicePause.unpause()
819 elif pauseFlag == 'P':
821 except Exception, ErrMsg:
822 print "onPause ERR :", ErrMsg
825 from libshm import SimpleSharedMemory
827 class HbbTVWindow(Screen, InfoBarNotifications):
829 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
832 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
833 self._session = session
834 setResolution(1280, 720)
835 fbClass.getInstance().lock()
836 eRCInput.getInstance().lock()
838 Screen.__init__(self, session)
839 InfoBarNotifications.__init__(self)
840 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
841 iPlayableService.evStart: self._serviceStarted,
842 iPlayableService.evEOF: self._serviceEOF,
846 self._use_ait = useAIT
847 self._profile = profile
848 self._cb_closed_func = cbf
849 self.onLayoutFinish.append(self._layoutFinished)
851 command_server = getCommandServer()
852 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
853 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
855 if self._cb_close_window not in command_server.onHbbTVCloseCB:
856 command_server.onHbbTVCloseCB.append(self._cb_close_window)
858 self._closeTimer = eTimer()
859 self._closeTimer.callback.append(self._do_close)
861 self._currentServicePositionTimer = eTimer()
862 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
869 def getVodPlayTime(self):
871 service = self._session.nav.getCurrentService()
872 seek = service and service.seek()
874 p = seek.getPlayPosition()
875 if(not l[0] and not p[0]):
881 def _cb_currentServicePosition(self):
882 def getTimeString(t):
883 t = time.localtime(t/90000)
884 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
885 position,length = 0,0
887 (position,length) = self.getVodPlayTime()
888 self._vod_length = length
889 if position == -1 and length == -1:
890 raise Exception("Can't get play status")
891 #print getTimeString(position), "/", getTimeString(length)
892 self._ssm.setStatus(position, length, 1)
893 except Exception, ErrMsg:
897 def _serviceStarted(self):
899 self._ssm.setStatus(0, 0, 0)
900 self._currentServicePositionTimer.start(1000)
901 except Exception, ErrMsg:
904 def _serviceEOF(self):
905 (position,length) = self.getVodPlayTime()
906 self._ssm.setStatus(length, length, 1)
908 self._currentServicePositionTimer.stop()
910 def _layoutFinished(self):
912 __gval__.hbbtv_handelr._soft_volume = -1
913 self.setTitle(_('HbbTV Plugin'))
914 command_util = getCommandUtil()
915 profile = self._profile
916 (sid, onid, tsid, name, orgid) = getChannelInfos()
917 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
919 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
921 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
923 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
925 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
927 def _cb_close_window(self):
928 self._closeTimer.start(1000)
931 self._closeTimer.stop()
932 command_server = getCommandServer()
934 if self._cb_set_page_title in command_server.onSetPageTitleCB:
935 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
936 except Exception, ErrMsg: pass
938 if self._cb_close_window in command_server.onHbbTVCloseCB:
939 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
940 except Exception, ErrMsg: pass
942 if self._cb_closed_func is not None:
943 self._cb_closed_func()
946 fbClass.getInstance().unlock()
947 eRCInput.getInstance().unlock()
950 def _cb_set_page_title(self, title=None):
951 print "page title :",title
956 class HbbTVHelper(Screen, InfoBarNotifications):
957 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
958 def __init__(self, session):
960 __gval__.hbbtv_handelr = HandlerHbbTV(session)
961 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
963 Screen.__init__(self, session)
964 InfoBarNotifications.__init__(self)
966 self._session = session
968 self._restart_opera()
970 self._timer_infobar = eTimer()
971 self._timer_infobar.callback.append(self._cb_registrate_infobar)
972 self._timer_infobar.start(1000)
974 self._excuted_browser = False
977 __gval__.command_util = BrowserCommandUtil()
981 _g_ssm_ = SimpleSharedMemory()
984 self._callbackStartStop = None
986 self.__et = ServiceEventTracker(screen=self, eventmap={
987 iPlayableService.evHBBTVInfo: self._cb_detectedAIT,
988 iPlayableService.evUpdatedInfo: self._cb_updateInfo
990 self._applicationList = None
992 self.mVuplusBox = False
993 issue = open("/etc/issue").read()
994 if(issue.startswith("Vuplus")):
995 self.mVuplusBox = True
997 def _cb_detectedAIT(self):
998 name = self._cb_ready_for_ait()
999 if name is not None and self.mVuplusBox:
1000 from Screens.InfoBarGenerics import gHbbtvApplication
1001 gHbbtvApplication.setApplicationName(str(name))
1003 def _cb_updateInfo(self):
1004 if not self._excuted_browser:
1005 command_util = getCommandUtil()
1006 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1008 from Screens.InfoBarGenerics import gHbbtvApplication
1009 gHbbtvApplication.setApplicationName("")
1010 #self._applicationList = None
1012 def _cb_registrate_infobar(self):
1013 if InfoBar.instance:
1014 self._timer_infobar.stop()
1015 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
1016 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
1018 def _cb_ready_for_ait(self):
1019 setChannelInfo(None, None, None, None, None)
1021 service = self._session.nav.getCurrentService()
1022 info = service and service.info()
1023 if info is not None:
1024 sid = info.getInfo(iServiceInformation.sSID)
1025 onid = info.getInfo(iServiceInformation.sONID)
1026 tsid = info.getInfo(iServiceInformation.sTSID)
1027 name = info.getName()
1031 pmtid = info.getInfo(iServiceInformation.sPMTPID)
1032 demux = info.getInfoString(iServiceInformation.sLiveStreamDemuxId)
1034 from aitreader import eAITSectionReader
1035 reader = eAITSectionReader(demux, pmtid, sid)
1036 if reader.doOpen(info, self.mVuplusBox):
1037 reader.doParseApplications()
1039 else: print "no data!!"
1042 self._applicationList = reader.getApplicationList()
1043 if len(self._applicationList) > 0:
1044 orgid = int(self._applicationList[0]["orgid"])
1045 setChannelInfo(sid, onid, tsid, name, orgid)
1046 return self._applicationList[0]["name"]
1050 def _cb_hbbtv_activated(self, title=None, url=None):
1051 if not self._is_browser_running():
1052 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1053 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1055 service = self._session.nav.getCurrentlyPlayingServiceReference()
1056 setBeforeService(service)
1057 self._start_hbbtv_application(title, url)
1059 def _start_hbbtv_application(self, title, url):
1061 tmp_url = self.getStartHbbTVUrl()
1065 print "can't get url of hbbtv!!"
1067 print "success to get url of hbbtv!! >>", url
1068 if self._excuted_browser:
1069 print "already excuted opera browser!!"
1073 self._restart_opera()
1075 setNeedRestart(False)
1077 for x in self._applicationList:
1078 control_code = int(x["control"])
1080 if tmp_url == url and control_code == 1:
1082 self._excuted_browser = True
1083 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1085 def _cb_closed_browser(self):
1086 self._excuted_browser = False
1088 def _start_opera(self):
1089 if not self._is_browser_running():
1090 global HBBTVAPP_PATH
1092 start_command = '%s/launcher start %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY)
1093 os.system(start_command)
1096 def _stop_opera(self):
1097 global HBBTVAPP_PATH
1098 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1101 def _restart_opera(self):
1102 global HBBTVAPP_PATH
1104 try: os.system('%s/launcher restart %d %d'%(HBBTVAPP_PATH, __gval__.resX, __gval__.resY))
1108 def getStartHbbTVUrl(self):
1109 url, self._profile = None, 0
1110 if self._applicationList is not None:
1111 for u in self._applicationList:
1112 if u["control"] in (1, -1):
1114 self._profile = u["profile"]
1116 service = self._session.nav.getCurrentService()
1117 info = service and service.info()
1118 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1121 def showApplicationSelectionBox(self):
1124 if self.getStartHbbTVUrl():
1125 for x in self._applicationList:
1126 applications.append((x["name"], x))
1127 else: applications.append((_("No detected HbbTV applications."), None))
1128 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1130 def _application_selected(self, selected):
1133 if selected[1] is None: return
1134 self._cb_hbbtv_activated(selected[1]["name"], selected[1]["url"])
1135 except Exception, ErrMsg: print ErrMsg
1137 def showBrowserConfigBox(self, callback=None):
1138 start_stop_mode = []
1139 self._callbackStartStop = callback
1140 if self._is_browser_running():
1141 start_stop_mode.append((_('Stop'),'Stop'))
1142 else: start_stop_mode.append((_('Start'),'Start'))
1143 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1145 def _browser_config_selected(self, selected):
1146 if selected is None:
1148 if self._callbackStartStop is not None:
1149 self._callbackStartStop()
1153 if not self._is_browser_running():
1155 elif mode == 'Stop':
1157 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1159 def _is_browser_running(self):
1161 global HBBTVAPP_PATH
1162 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1163 return ret.strip() != "0"
1164 except Exception, ErrMsg:
1165 print "Check Browser Running ERR :", ErrMsg
1168 def doChangeChannel(self, _sid, _tsid):
1169 root = eServiceReference(service_types_tv)
1172 serviceList = eServiceCenter.getInstance().list(root)
1173 if serviceList is None:
1176 service = serviceList.getNext()
1177 if service is None or not service.valid():
1180 #1:0:19:2840:3FB:1:C00000:0:0:0:
1181 serviceRef = service.toString()
1182 if strIsEmpty(serviceRef):
1184 serviceRefItems = serviceRef.split(":")
1185 if len(serviceRefItems) < 5:
1188 sid = serviceRefItems[3]
1189 tsid = serviceRefItems[4]
1190 if sid == _sid and tsid == _tsid:
1191 self._session.nav.playService(eServiceReference(serviceRef))
1192 service = self._session.nav.getCurrentlyPlayingServiceReference()
1193 setBeforeService(service)
1197 class OperaBrowserSetting:
1199 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1205 f = open(self._settingFileName)
1206 for line in f.readlines():
1207 if line.startswith('start='):
1208 tmp = line[6:len(line)-1].split()
1209 self._start = tmp[0]
1211 self._type = int(tmp[1])
1212 else: self._type = 0
1213 elif line.startswith('keymap='):
1214 self._keymap = line[7:len(line)-1]
1218 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1219 tmpstr.append('keymap=%s\n' % (self._keymap))
1220 f = open(self._settingFileName, 'w')
1221 f.writelines(tmpstr)
1223 def setData(self, start, types=0, keymap="us-rc"):
1226 self._keymap = keymap
1230 'start':self._start,
1232 'keymap':self._keymap,
1235 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1237 <screen position="center,120" size="600,350" title="Preference">
1238 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1239 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1241 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1242 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1244 <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" />
1245 <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" />
1248 def __init__(self, session, currentUrl):
1249 self.session = session
1250 Screen.__init__(self, session)
1253 ConfigListScreen.__init__(self, self.menulist)
1255 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1256 "red" : self.keyRed,
1257 "green" : self.keyGreen,
1259 "cancel" : self.keyRed
1261 self["key_red"] = StaticText(_("Cancel"))
1262 self["key_green"] = StaticText(_("Save"))
1263 self["url"] = Label()
1265 self._currentPageUrl = currentUrl
1266 if self._currentPageUrl is None:
1267 self._currentPageUrl = ''
1268 self._startPageUrl = None
1269 self._keymapType = None
1270 self.makeMenuEntry()
1271 self.onLayoutFinish.append(self.layoutFinished)
1273 def layoutFinished(self):
1274 self.setTitle(_('Preference'))
1276 def updateStartPageUrl(self):
1277 if self.menuItemStartpage.value == "startpage":
1278 self["url"].setText(self._startPageUrl)
1279 elif self.menuItemStartpage.value == "current":
1280 self["url"].setText(self._currentPageUrl)
1281 elif self.menuItemStartpage.value == "direct":
1282 self["url"].setText('')
1285 url = self["url"].getText()
1287 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1290 if url.find('/usr/local/manual') > 0:
1292 self._keymapType = self.menuItemKeyboardLayout.value
1293 OperaBrowserSetting().setData(url, mode, self._keymapType)
1294 command_util = getCommandUtil()
1295 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1302 def _cb_directInputUrl(data):
1303 if strIsEmpty(data):
1305 self["url"].setText(data)
1306 if self.menuItemStartpage.value == "direct":
1307 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1310 ConfigListScreen.keyLeft(self)
1311 self.updateStartPageUrl()
1314 ConfigListScreen.keyRight(self)
1315 self.updateStartPageUrl()
1317 def getKeymapTypeList(self):
1319 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1320 filesplit = f.split('.')
1321 if len(filesplit) < 2:
1323 types.append((filesplit[1], filesplit[1]))
1327 def makeMenuEntry(self):
1329 l.append(("startpage", _("Start Page")))
1330 if not strIsEmpty(self._currentPageUrl):
1331 l.append(("current", _("Current Page")))
1332 l.append(("direct", _("Direct Input")))
1333 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1334 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1336 kl = self.getKeymapTypeList()
1339 d = OperaBrowserSetting().getData()
1340 self._startPageUrl = d['start']
1341 self._keymapType = d['keymap']
1343 except: self._startPageUrl = 'http://vuplus.com'
1344 self.updateStartPageUrl()
1346 if self._keymapType is None or len(self._keymapType) == 0:
1347 self._keymapType = "us-rc"
1348 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1349 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1350 self.resetMenuList()
1352 def resetMenuList(self):
1354 self.menulist.append(self.menuEntryStartpage)
1355 self.menulist.append(self.menuEntryKeyboardLayout)
1357 self["config"].list = self.menulist
1358 self["config"].l.setList(self.menulist)
1360 class BookmarkEditWindow(ConfigListScreen, Screen):
1361 CATEGORY,BOOKMARK = 0,1
1363 <screen position="center,center" size="600,140" title="Bookmark Edit">
1364 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1366 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1367 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1369 <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" />
1370 <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" />
1372 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1376 def __init__(self, session, _mode, _type, _data, _bm):
1380 self.mSession = session
1381 self.mBookmarkManager = _bm
1383 if _data is not None:
1386 Screen.__init__(self, session)
1389 ConfigListScreen.__init__(self, self.menulist)
1391 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1392 "ok" : self.keyGreen,
1393 "green" : self.keyGreen,
1394 "red" : self.keyRed,
1395 "cancel" : self.keyRed,
1398 self["VKeyIcon"] = Pixmap()
1399 self["key_red"] = StaticText(_("Cancel"))
1400 self["key_green"] = StaticText(_("Save"))
1402 self.menuItemTitle = None
1403 self.menuItemUrl = None
1404 self.menuItemName = None
1406 self.menuEntryName = None
1407 self.menuEntryTitle = None
1408 self.menuEntryUrl = None
1410 self.makeConfigList()
1411 self.onLayoutFinish.append(self.layoutFinished)
1413 def layoutFinished(self):
1414 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1416 def selectedItem(self):
1417 currentPosition = self["config"].getCurrent()
1418 if self.mType == BookmarkEditWindow.CATEGORY:
1419 return (_("Name"), self.menuItemName)
1421 if currentPosition == self.menuEntryTitle:
1422 return (_("Title"), self.menuItemTitle)
1423 elif currentPosition == self.menuEntryUrl:
1424 return (_("Url"), self.menuItemUrl)
1427 def showMessageBox(self, text):
1428 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1429 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1432 def showVKeyWindow(self, data=None):
1435 selected = self.selectedItem()
1436 if selected is not None:
1437 itemValue = selected[1].value
1438 if strIsEmpty(itemValue):
1440 itemTitle = selected[0]
1442 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1444 def cbVKeyWindow(self, data=None):
1445 if data is not None:
1446 selected = self.selectedItem()
1447 if selected is not None:
1448 selected[1].setValue(data)
1451 if self.mType == BookmarkEditWindow.CATEGORY:
1452 if self.mMode == _('Add'):
1453 categoryName = self.menuItemName.value
1454 if strIsEmpty(categoryName):
1455 return self.showMessageBox(_("Category Name"))
1456 self.mBookmarkManager.addCategory(categoryName)
1458 if strIsEmpty(self.menuItemName.value):
1459 return self.showMessageBox(_("Category Name"))
1460 self.mData.mName = self.menuItemName.value
1461 self.mBookmarkManager.updateCategory(self.mData)
1463 if self.mMode == _('Add'):
1464 bookmarkTitle = self.menuItemTitle.value
1465 bookmarkUrl = self.menuItemUrl.value
1466 if strIsEmpty(bookmarkTitle):
1467 self["config"].setCurrentIndex(0)
1468 return self.showMessageBox(_("Bookmark Title"))
1469 if strIsEmpty(bookmarkUrl):
1470 self["config"].setCurrentIndex(1)
1471 return self.showMessageBox(_("Bookmark URL"))
1472 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1474 if strIsEmpty(self.menuItemTitle.value):
1475 self["config"].setCurrentIndex(0)
1476 return self.showMessageBox(_("Bookmark Title"))
1477 if strIsEmpty(self.menuItemUrl.value):
1478 self["config"].setCurrentIndex(1)
1479 return self.showMessageBox(_("Bookmark URL"))
1480 self.mData.mTitle = self.menuItemTitle.value
1481 self.mData.mUrl = self.menuItemUrl.value
1482 self.mBookmarkManager.updateBookmark(self.mData)
1486 if not self.saveData():
1492 ConfigListScreen.keyLeft(self)
1494 ConfigListScreen.keyRight(self)
1495 def makeConfigList(self):
1498 if self.mType == BookmarkEditWindow.CATEGORY:
1499 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1501 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1503 self.menulist.append(self.menuEntryName)
1505 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1506 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1508 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1509 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1511 self.menulist.append(self.menuEntryTitle)
1512 self.menulist.append(self.menuEntryUrl)
1514 self["config"].list = self.menulist
1515 self["config"].l.setList(self.menulist)
1517 class OperaBrowserBookmarkWindow(Screen):
1519 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1520 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1522 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1523 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1525 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1526 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1527 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1528 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1530 <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" />
1531 <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" />
1532 <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" />
1533 <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" />
1537 def __init__(self, _session, _url=None, _title=None):
1539 self.mTitle = _title
1540 self.mBookmarkManager = BookmarkManager.getInstance()
1541 self.mSession = _session
1542 Screen.__init__(self, _session)
1543 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1545 "cancel": self.keyCancel,
1546 "red" : self.keyRed,
1547 "green" : self.keyGreen,
1548 "yellow": self.keyYellow,
1549 "blue" : self.keyBlue,
1550 "0" : self.keyNumber,
1553 self["key_red"] = StaticText(_("Exit"))
1554 self["key_green"] = StaticText(_("Add"))
1555 self["key_yellow"] = StaticText(_("Edit"))
1556 self["key_blue"] = StaticText(_("Delete"))
1557 self["key_0"] = StaticText(_("Set as Startpage"))
1559 self.mBookmarkList = self.setBookmarkList()
1560 self["bookmarklist"] = MenuList(self.mBookmarkList)
1562 self.onLayoutFinish.append(self.layoutFinished)
1564 def layoutFinished(self):
1565 self.setTitle(_('Bookmark'))
1567 def setBookmarkList(self):
1569 #self.mBookmarkManager.dump()
1570 cd = self.mBookmarkManager.getBookmarkRoot()
1571 for ck in cd.iterkeys():
1572 l.append(('# ' + cd[ck].mName, cd[ck]))
1573 bd = cd[ck].mBookmarks
1574 for bk in bd.iterkeys():
1575 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1577 def updateBookmarkList(self):
1578 self.mBookmarkList = self.setBookmarkList()
1579 self["bookmarklist"].setList(self.mBookmarkList)
1580 def cbEditWindow(self, ret=False):
1583 self.updateBookmarkList()
1584 def getParentCategory(self):
1585 idx = self["bookmarklist"].getSelectedIndex()
1588 data = self.mBookmarkList[idx][0].strip()
1590 return self.mBookmarkList[idx][1]
1594 def isCategoryItem(self):
1596 head = self["bookmarklist"].getCurrent()[0].strip()
1601 def keyNumber(self):
1602 data = self["bookmarklist"].getCurrent()[1]
1603 if strIsEmpty(data.mUrl):
1604 msg = _("Invalid URL. Please check again!!")
1605 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1607 def cbSetStartpage(ret=None):
1608 if ret is None: return
1610 data = self["bookmarklist"].getCurrent()[1]
1611 OperaBrowserSetting().setData(data.mUrl, data.mType)
1612 msg = _("Do you want to set selected url to the Startpage?")
1613 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1620 parent = self.getParentCategory()
1623 if strIsEmpty(self.mTitle):
1625 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1627 msg = _("Current page is already exist.")
1628 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1629 self.cbEditWindow(True)
1631 parent = self.getParentCategory()
1634 b = BookmarkData(0, '', '', parent.mId, 0)
1635 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1637 c = CategoryData(0, '')
1638 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1639 if strIsEmpty(self.mUrl):
1640 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1641 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1642 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1643 def keyYellow(self):
1644 data = self["bookmarklist"].getCurrent()[1]
1645 if self.isCategoryItem():
1646 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1647 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1649 def cbBlue(ret=None):
1651 data = self["bookmarklist"].getCurrent()[1]
1652 if self.isCategoryItem():
1653 self.mBookmarkManager.deleteCategory(data.mId)
1654 else: self.mBookmarkManager.deleteBookmark(data.mId)
1655 self.updateBookmarkList()
1656 if self.isCategoryItem():
1657 msg = _("Do you want to delete the category and the bookmarks?")
1658 else: msg = _("Do you want to delete the bookmark?")
1659 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1661 if self.isCategoryItem(): return
1663 data = self["bookmarklist"].getCurrent()[1]
1664 url = data.mUrl.strip()
1666 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1670 lang = language.getLanguage()
1671 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1672 url = '/usr/local/manual/ru_RU/main.html'
1673 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1674 url = '/usr/local/manual/de_DE/main.html'
1675 self.close((url, mode))
1678 def keyCancel(self):
1681 class BrowserHelpWindow(Screen, HelpableScreen):
1682 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1684 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1685 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1686 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1687 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1688 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1690 <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" />
1691 <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" />
1692 <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" />
1693 <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" />
1696 def __init__(self, session):
1697 Screen.__init__(self, session)
1698 HelpableScreen.__init__(self)
1700 self["key_red"] = StaticText(_("Exit"))
1701 self["key_green"] = StaticText(_("Global"))
1702 self["key_yellow"] = StaticText(_("Mouse"))
1703 self["key_blue"] = StaticText(_("Keyboard"))
1705 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1707 "cancel": self.keyRed,
1708 "red" : self.keyRed,
1709 "green" : self.keyGreen,
1710 "yellow": self.keyYellow,
1711 "blue" : self.keyBlue,
1714 self.showHelpTimer = eTimer()
1715 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1716 self.showHelpTimer.start(500)
1718 self.onLayoutFinish.append(self.layoutFinished)
1720 def layoutFinished(self):
1721 self.setTitle(_('Browser Help'))
1723 def cbShowHelpTimerClosed(self):
1724 self.showHelpTimer.stop()
1725 self.setHelpModeActions(self.MODE_GLOBAL)
1727 def setHelpModeActions(self, _mode=0):
1729 if _mode == self.MODE_GLOBAL:
1730 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1731 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1733 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1734 "menu" : (self.keyPass, _("Show the Menu window.")),
1736 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1737 "green" : (self.keyPass, _("Enter Key")),
1738 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1739 "blue" : (self.keyPass, _("Backspace Key")),
1741 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1742 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1745 elif _mode == self.MODE_MOUSE:
1746 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1747 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1748 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1749 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1750 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1752 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1753 "ok" : (self.keyPass, _("Left Mouse Button")),
1755 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1756 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1757 "nextService" : (self.keyPass, _("Left Key")),
1758 "prevService" : (self.keyPass, _("Right Key")),
1760 elif _mode == self.MODE_KEYBOARD:
1761 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1762 "up" : (self.keyPass, _("Up Key")),
1763 "down" : (self.keyPass, _("Down Key")),
1764 "left" : (self.keyPass, _("Left Key")),
1765 "right" : (self.keyPass, _("Right Key")),
1767 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1768 "ok" : (self.keyPass, _("Enter Key")),
1770 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1771 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1772 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1773 "nextService" : (self.keyPass, _("Go to previous page.")),
1774 "prevService" : (self.keyPass, _("Go to next page.")),
1786 self.setHelpModeActions(self.MODE_GLOBAL)
1787 def keyYellow(self):
1788 self.setHelpModeActions(self.MODE_MOUSE)
1790 self.setHelpModeActions(self.MODE_KEYBOARD)
1792 class OperaBrowser(Screen):
1793 MENUBAR_ITEM_WIDTH = 150
1794 MENUBAR_ITEM_HEIGHT = 30
1795 SUBMENULIST_WIDTH = 200
1796 SUBMENULIST_HEIGHT = 25
1797 SUBMENULIST_NEXT = 2
1799 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1800 # menulist->size->x : SUBMENULIST_WIDTH
1801 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1802 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1803 # submenulist->size->x : SUBMENULIST_WIDTH
1805 size = getDesktop(0).size()
1806 WIDTH = int(size.width())
1807 HEIGHT = int(size.height())
1809 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1810 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1811 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1812 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1813 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1814 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1815 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1816 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1818 """ % { 'width' :WIDTH,
1820 'bottom_pos_y' :HEIGHT-80,
1821 'bottom_size_x' :WIDTH }
1825 def __init__(self, session, url=None, isWebAppMode=False):
1826 Screen.__init__(self, session)
1827 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1828 "cancel" : self.keyCancel
1830 ,"left" : self.keyLeft
1831 ,"right" : self.keyRight
1833 ,"down" : self.keyDown
1834 ,"menu" : self.keyMenu
1837 self.UpdateLanguageCB()
1839 self._terminatedBrowser = True
1840 self._enableKeyEvent = True
1841 self._currentPageUrl = None
1842 self._currentPageTitle = None
1843 self.menubarCurrentIndex = 0
1844 self.lvMenuItems = []
1845 self.lvSubMenuItems = []
1847 self["topArea"] = Label()
1848 self["bottomArea"] = Label()
1850 self["menuitemFile"] = MultiColorLabel()# modify menu
1851 self["menuitemTool"] = MultiColorLabel()
1852 self["menuitemHelp"] = MultiColorLabel()
1854 self["menulist"] = MenuList(self.setListOnView())
1855 self["submenulist"] = MenuList(self.setSubListOnView())
1857 self.toggleMainScreenFlag = True
1858 self.toggleListViewFlag = False
1859 self.toggleSubListViewFlag = False
1860 self.currentListView = self["menulist"]
1862 self.onLayoutFinish.append(self.layoutFinished)
1864 self._onCloseTimer = eTimer()
1865 self._onCloseTimer.callback.append(self._cb_onClose)
1868 self.paramIsWebAppMode = isWebAppMode
1869 language.addCallback(self.UpdateLanguageCB)
1871 def UpdateLanguageCB(self):
1873 self.MENUITEMS_LIST = [
1874 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1875 [(_('Bookmark'), None), (_('Preference'), None)],
1876 [(_('About'), None), (_('Help'), None)]]
1877 self.COMMAND_MAP = {}
1878 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1879 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1880 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1881 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1882 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1883 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1884 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1885 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1886 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1888 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1889 rcmouse_path = "/proc/stb/fp/mouse"
1890 if os.path.exists(rcmouse_path):
1891 os.system("echo %d > %s" % (mode, rcmouse_path))
1893 def layoutFinished(self):
1894 self["menuitemFile"].setText(_("File"))# modify menu
1895 self["menuitemTool"].setText(_("Tools"))
1896 self["menuitemHelp"].setText(_("Help"))
1898 self["menulist"].hide()
1899 self["submenulist"].hide()
1901 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1902 self.setTitle(_("BrowserMain"))
1903 self.selectMenuitem()
1905 if self.paramUrl is not None:
1907 if self.paramIsWebAppMode:
1908 self.cbUrlText(data=self.paramUrl, mode=1, opcode='OP_BROWSER_OPEN_YOUTUBETV')
1909 else: self.cbUrlText(data=self.paramUrl, mode=1)
1911 def selectMenuitem(self):
1912 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1913 self["menuitemFile"].setForegroundColorNum(0)
1914 self["menuitemTool"].setForegroundColorNum(0)
1915 self["menuitemHelp"].setForegroundColorNum(0)
1916 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1918 def popupCloseAll(self):
1924 def setListOnView(self):
1925 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1926 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1927 l = [(_('Return'), None)]
1928 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1929 return self.lvMenuItems
1931 def setSubListOnView(self):
1932 self.lvSubMenuItems = []
1933 xl = self["menulist"].getCurrent()[1]
1934 if xl is None: return []
1936 self.lvSubMenuItems.append((x,None))
1937 return self.lvSubMenuItems
1939 def toggleMainScreen(self):
1940 if not self.toggleMainScreenFlag:
1943 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1945 def toggleListView(self):
1946 if not self.toggleListViewFlag:
1947 self["menulist"].show()
1948 else: self["menulist"].hide()
1949 self.toggleListViewFlag = not self.toggleListViewFlag
1951 def toggleSubListView(self):
1952 if not self.toggleSubListViewFlag:
1953 self["submenulist"].show()
1954 else: self["submenulist"].hide()
1955 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1957 def setCurrentListView(self, listViewIdx):
1958 if listViewIdx == 0:
1959 self.currentListView = None
1960 elif listViewIdx == 1:
1961 self.currentListView = self["menulist"]
1962 elif listViewIdx == 2:
1963 self.currentListView = self["submenulist"]
1965 def _cb_onClose(self):
1966 self._onCloseTimer.stop()
1967 command_server = getCommandServer()
1969 if self._on_close_window in command_server.onHbbTVCloseCB:
1970 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1971 except Exception, ErrMsg: pass
1973 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1974 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1975 except Exception, ErrMsg: pass
1976 self._on_setPageTitle(_('Opera Browser'))
1977 self.enableRCMouse(False)
1978 self.toggleMainScreen()
1980 fbClass.getInstance().unlock()
1981 eRCInput.getInstance().unlock()
1982 self._terminatedBrowser = True
1983 self._enableKeyEvent = True
1984 #if not self.toggleListViewFlag:
1987 self._currentPageUrl = ''
1988 if self.paramUrl is not None:
1994 def _on_setPageTitle(self, title=None):
1995 print "Title :",title
1998 self.setTitle(title)
2000 def cbUrlText(self, data=None, mode=0, opcode='OP_BROWSER_OPEN_URL'):
2002 if not _g_helper._is_browser_running():
2004 print "Inputed Url :", data, mode
2005 if strIsEmpty(data):
2008 command_server = getCommandServer()
2009 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
2010 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
2011 if self._on_close_window not in command_server.onHbbTVCloseCB:
2012 command_server.onHbbTVCloseCB.append(self._on_close_window)
2013 self.toggleMainScreen()
2014 self.enableRCMouse(True)
2016 fbClass.getInstance().lock()
2017 eRCInput.getInstance().lock()
2019 #setResolution(1280, 720)
2021 command_util = getCommandUtil()
2022 command_util.sendCommand(opcode, data, mode)
2023 self._terminatedBrowser = False
2024 self._enableKeyEvent = False
2027 __gval__.hbbtv_handelr._soft_volume = -1
2029 def _on_close_window(self):
2030 self._onCloseTimer.start(1000)
2032 def _cb_bookmarkWindowClosed(self, data=None):
2037 if not _g_helper._is_browser_running():
2038 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2039 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2041 self.cbUrlText(url, mode)
2043 def _cmd_on_OpenUrl(self):
2045 if not _g_helper._is_browser_running():
2046 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2047 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2049 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2050 def _cmd_on_About(self):
2051 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2052 def _cmd_on_Exit(self):
2054 def _cb_cmdOnStartSTop(self):
2056 def _cmd_on_StartStop(self):
2058 if _g_helper is None:
2060 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2062 def _cmd_on_Bookmark(self):
2063 url = self._currentPageUrl
2066 title = self._currentPageTitle
2069 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2070 def _cmd_on_Preference(self):
2071 url = self._currentPageUrl
2074 self.session.open(OperaBrowserPreferenceWindow, url)
2075 def _cmd_on_OpenStartpage(self):
2077 if not _g_helper._is_browser_running():
2078 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2079 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2082 start = 'http://vuplus.com'
2084 d = OperaBrowserSetting().getData()
2088 self.cbUrlText(start, mode)
2089 def _cmd_on_ReturnToBrowser(self):
2092 def _cmd_on_Help(self):
2093 self.session.open(BrowserHelpWindow)
2095 def doCommand(self, command):
2097 self.COMMAND_MAP[command]()
2098 except Exception, ErrMsg: print ErrMsg
2101 if not self.toggleMainScreenFlag:
2104 if not self.toggleListViewFlag:
2107 if self.currentListView.getCurrent()[1] is None:
2108 self.doCommand(self.currentListView.getCurrent()[0])
2109 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2113 def updateSelectedMenuitem(self, status):
2114 if self.menubarCurrentIndex == 0 and status < 0:
2115 self.menubarCurrentIndex = 2 # modify menu
2116 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2117 self.menubarCurrentIndex = 0
2118 else: self.menubarCurrentIndex += status
2119 self.selectMenuitem()
2122 if not self.toggleMainScreenFlag:
2124 if not self.toggleListViewFlag:
2125 self.updateSelectedMenuitem(-1)
2127 if self.toggleSubListViewFlag:
2128 self.setCurrentListView(1)
2129 self.toggleSubListView()
2131 #if self.currentListView.getSelectedIndex():
2132 self.currentListView.pageUp()
2138 if not self.toggleMainScreenFlag:
2140 if not self.toggleListViewFlag:
2141 self.updateSelectedMenuitem(1)
2143 if self.currentListView is None:
2145 if self.currentListView.getCurrent()[1] is not None:
2146 parentSelectedIndex = self.currentListView.getSelectedIndex()
2147 self.setCurrentListView(2)
2148 self.currentListView.setList(self.setSubListOnView())
2149 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2150 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))
2151 self.toggleSubListView()
2153 self.currentListView.pageUp()
2159 if not self.toggleMainScreenFlag:
2161 if self.currentListView is None:
2163 if not self.toggleListViewFlag:
2164 self.currentListView.setList(self.setListOnView())
2165 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2166 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2167 self.toggleListView()
2169 self.currentListView.down()
2172 if not self.toggleMainScreenFlag:
2174 if self.currentListView is None:
2176 if self.currentListView == self["menulist"]:
2177 if self.currentListView.getSelectedIndex() == 0:
2178 self.toggleListView()
2180 self.currentListView.up()
2182 def keyCancel(self):
2183 if not self._terminatedBrowser:
2184 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2185 fbClass.getInstance().lock()
2186 eRCInput.getInstance().lock()
2187 #setResolution(1280, 720)
2188 if self.toggleListViewFlag:
2189 self.toggleMainScreen()
2190 self._currentPageUrl = None
2191 self._currentPageTitle = None
2192 command_util = getCommandUtil()
2193 command_util.sendCommand('OP_BROWSER_MENU_RES')
2198 self.toggleMainScreen()
2200 def setCurrentPageUrl(self, url, title=None):
2201 self._currentPageUrl = url
2204 if idx > 10: idx = 10
2206 self._currentPageTitle = title
2207 print self._currentPageUrl
2208 self.toggleMainScreen()
2212 def hideSubmenu(self):
2213 self.currentListView.pageUp()
2216 config.plugins.youtubetv = ConfigSubsection()
2217 config.plugins.youtubetv.showhelp = ConfigYesNo(default = False)
2218 config.plugins.youtubetv.uri = ConfigText(default = "http://www.youtube.com/tv", visible_width = 50, fixed_size = False)
2219 class YoutubeTVWindow(Screen, HelpableScreen):
2221 <screen name="YoutubeTVWindow" position="center,center" size="550,160" title="Start YouTube TV" >
2222 <widget name="infomation" position="5,0" size="540,80" valign="center" halign="center" font="Regular;20" />
2223 <widget name="startdesc" position="10,80" size="395,40" valign="center" font="Regular;20" />
2224 <widget name="helpdesc" position="10,120" size="395,40" valign="center" font="Regular;20" />
2225 <ePixmap pixmap="skin_default/buttons/green.png" position="400,80" size="140,40" alphatest="on" />
2226 <ePixmap pixmap="skin_default/buttons/yellow.png" position="400,120" size="140,40" alphatest="on" />
2227 <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" />
2228 <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" />
2231 def __init__(self, session):
2232 Screen.__init__(self, session)
2233 HelpableScreen.__init__(self)
2235 self["actions"] = ActionMap(["WizardActions", "DirectionActions", "OkCancelActions","ColorActions", "EPGSelectActions",], {
2236 "cancel": self.keyCancel,
2237 "red" : self.keyCancel,
2238 "green" : self.keyGreen,
2239 "yellow": self.keyYellow,
2242 self["key_green"] = StaticText(_("Start"))
2243 self["key_yellow"] = StaticText(_("Help"))
2245 self["infomation"] = Label()
2246 self["startdesc"] = Label()
2247 self["helpdesc"] = Label()
2249 self.onLayoutFinish.append(self.layoutFinished)
2251 def layoutFinished(self):
2252 self.setTitle(_('Start YouTube TV'))
2253 self["infomation"].setText(_("YouTube TV is a new way to watch YouTube videos on Vu+"))
2254 self["startdesc" ].setText(_("* Start YouTube TV"))
2255 self["helpdesc" ].setText(_("* RC Help"))
2257 def setHelpModeActions(self):
2259 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
2260 "ok" : (self.keyPass, _("Play ther selected the video")),
2261 "cancel": (self.keyPass, _("Exit the YouTube TV")),
2263 self["EventViewActions"] = HelpableActionMap(self, "EventViewActions", {
2264 "pageUp" : (self.keyPass, _("Move up")),
2265 "pageDown" : (self.keyPass, _("Move down")),
2266 "prevEvent" : (self.keyPass, _("Move left")),
2267 "nextEvent" : (self.keyPass, _("Move right")),
2269 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
2270 "info" : (self.keyPass, _("Search a video")),
2271 "nextService" : (self.keyPass, _("Skip forward 10 sec")),
2272 "prevService" : (self.keyPass, _("Skip backward 10 sec")),
2274 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", {
2275 "play" : (self.keyPass, _("Play current video")),
2276 "pause" : (self.keyPass, _("Pause current video")),
2277 "stop" : (self.keyPass, _("Stop current video")),
2279 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
2280 "red" : (self.keyPass, _("Back")),
2286 def keyCancel(self):
2287 config.plugins.youtubetv.showhelp.cancel()
2290 config.plugins.youtubetv.showhelp.save()
2291 config.plugins.youtubetv.save()
2292 config.plugins.save()
2294 def keyYellow(self):
2295 self.setHelpModeActions()
2297 if config.plugins.youtubetv.showhelp.value == True :
2298 config.plugins.youtubetv.showhelp.setValue(False)
2299 else: config.plugins.youtubetv.showhelp.setValue(True)
2301 class YoutubeTVSettings(ConfigListScreen, Screen):
2303 <screen position="center,center" size="600,140" title="YouTube TV Settings">
2304 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
2306 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
2307 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
2309 <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" />
2310 <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" />
2313 def __init__(self, session):
2314 self.session = session
2315 Screen.__init__(self, session)
2318 ConfigListScreen.__init__(self, self.menulist)
2320 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
2321 "ok" : self.keyGreen,
2322 "green" : self.keyGreen,
2323 "red" : self.keyRed,
2324 "cancel" : self.keyRed,
2327 self["key_red"] = StaticText(_("Cancel"))
2328 self["key_green"] = StaticText(_("Save"))
2330 self.makeConfigList()
2331 self.onLayoutFinish.append(self.layoutFinished)
2333 def layoutFinished(self):
2334 self.setTitle(_('YouTube TV Settings'))
2337 config.plugins.youtubetv.showhelp.save()
2338 config.plugins.youtubetv.uri.save()
2339 config.plugins.youtubetv.save()
2340 config.plugins.save()
2343 config.plugins.youtubetv.showhelp.cancel()
2344 config.plugins.youtubetv.uri.cancel()
2348 ConfigListScreen.keyLeft(self)
2351 ConfigListScreen.keyRight(self)
2353 def makeConfigList(self):
2355 entryUri = getConfigListEntry(_("YouTube TV URL"), config.plugins.youtubetv.uri)
2356 entryShowHelp = getConfigListEntry(_("Do not show YouTube TV Stater again"), config.plugins.youtubetv.showhelp)
2357 self.menulist.append(entryUri)
2358 self.menulist.append(entryShowHelp)
2360 self["config"].list = self.menulist
2361 self["config"].l.setList(self.menulist)
2363 def auto_start_main(reason, **kwargs):
2365 command_server = getCommandServer()
2366 command_server.stop()
2368 from Screens.HelpMenu import HelpableScreen
2369 def session_start_main(session, reason, **kwargs):
2370 fbClass.getInstance().unlock()
2371 eRCInput.getInstance().unlock()
2373 from enigma import getDesktop
2374 desktopSize = getDesktop(0).size()
2375 setDefaultResolution(desktopSize.width(), desktopSize.height())
2378 _g_helper = session.open(HbbTVHelper)
2380 HelpableScreen.__init__ = HelpableScreen__init__
2381 HelpableScreen.session = session
2383 def HelpableScreen__init__(self):
2384 if isinstance(self, HelpableScreen):
2385 HelpableScreen.showManual = showManual
2387 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2388 "help_b" : self.showHelp,
2389 "help_l" : self.showManual,
2392 _g_clearBrowserDataTimer = eTimer()
2393 def showManual(self):
2394 if not os.path.exists('/usr/local/manual'):
2397 url = 'file:///usr/local/manual/main.html'
2398 lang = language.getLanguage()
2399 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2400 url = 'file:///usr/local/manual/ru_RU/main.html'
2401 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2402 url = 'file:///usr/local/manual/de_DE/main.html'
2405 _g_clearBrowserDataTimer.stop()
2406 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2408 setPluginBrowser(None)
2409 def clearBrowserData():
2410 _g_clearBrowserDataTimer.callback.append(_do_clean)
2411 _g_clearBrowserDataTimer.start(50)
2412 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2414 _g_backupSession = None
2415 def showYoutubeTV(session, **kwargs):
2417 _g_clearBrowserDataTimer.stop()
2418 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2420 setPluginBrowser(None)
2421 global _g_backupSession
2423 service = getBeforeService()
2424 if service is not None:
2425 _g_backupSession.nav.playService(eServiceReference(service))
2426 _g_backupSession = None
2427 def clearBrowserData():
2428 _g_clearBrowserDataTimer.callback.append(_do_clean)
2429 _g_clearBrowserDataTimer.start(50)
2430 def cbYoutubeTVClose(ret):
2432 global _g_backupSession
2433 _g_backupSession = session
2434 service = session.nav.getCurrentlyPlayingServiceReference()
2435 if service is not None:
2436 setBeforeService(service.toString())
2437 session.nav.stopService()
2438 else: setBeforeService(service)
2439 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser, config.plugins.youtubetv.uri.value, True))
2440 if config.plugins.youtubetv.showhelp.value == True:
2441 cbYoutubeTVClose(True)
2442 else: session.openWithCallback(cbYoutubeTVClose, YoutubeTVWindow)
2444 def youtube_setting_main(session, **kwargs):
2445 session.open(YoutubeTVSettings)
2447 def start_menu_main(menuid, **kwargs):
2448 if menuid == "mainmenu":
2449 return [(_("YouTube TV"), showYoutubeTV, "youtube_tv", 46)]
2452 def plugin_start_main(session, **kwargs):
2453 #session.open(OperaBrowser)
2455 _g_clearBrowserDataTimer.stop()
2456 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2458 setPluginBrowser(None)
2459 def clearBrowserData():
2460 _g_clearBrowserDataTimer.callback.append(_do_clean)
2461 _g_clearBrowserDataTimer.start(50)
2462 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2464 def plugin_extension_start_application(session, **kwargs):
2466 if _g_helper is None:
2468 _g_helper.showApplicationSelectionBox()
2470 def plugin_extension_browser_config(session, **kwargs):
2472 if _g_helper is None:
2474 _g_helper.showBrowserConfigBox()
2476 def Plugins(path, **kwargs):
2478 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2479 l.append(PluginDescriptor(name=_("YouTube TV"), where=PluginDescriptor.WHERE_MENU, fnc=start_menu_main))
2480 l.append(PluginDescriptor(name=_("YouTube TV Settings"), where=PluginDescriptor.WHERE_PLUGINMENU, fnc=youtube_setting_main))
2481 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2482 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2483 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2484 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))