def init_page(self):
menu = self.menustack[-1]
if not menu:
return
# Create the list of main selection items (menu_items)
menu_items = []
first = menu.page_start
self.rows, self.cols = menu.items_per_page()
for choice in menu.choices[first:first + (self.rows * self.cols)]:
menu_items.append(choice)
self.rows, self.cols = menu.items_per_page()
self.menu_items = menu_items
if len(menu_items) == 0:
self.all_items = menu_items + [
MenuItem('Back', self.back_one_menu)
]
else:
self.all_items = menu_items
if not menu.selected in self.all_items:
menu.selected = self.all_items[0]
if not menu.choices:
menu.selected = self.all_items[0]
rc.post_event(MENU_PROCESS_END)
# make sure we are in context 'menu'
rc.set_context(self.event_context)
def eventhandler(self, event, menuw=None):
if event == DIRECTORY_CHANGE_DISPLAY_TYPE and menuw.menustack[
-1] == self.menu:
possible_display_types = []
for p in plugin.get('mimetype'):
for t in p.display_type:
if not t in possible_display_types:
possible_display_types.append(t)
try:
pos = possible_display_types.index(self.display_type)
type = possible_display_types[(pos + 1) %
len(possible_display_types)]
menuw.delete_menu(allow_reload=False)
newdir = DirItem(self.dir, self.parent, self.name, type,
self.add_args)
newdir.DIRECTORY_AUTOPLAY_SINGLE_ITEM = False
newdir.cwd(menuw=menuw)
menuw.menustack[-2].selected = newdir
pos = menuw.menustack[-2].choices.index(self)
menuw.menustack[-2].choices[pos] = newdir
rc.post_event(Event(OSD_MESSAGE, arg='%s view' % type))
return True
except (IndexError, ValueError):
pass
return Playlist.eventhandler(self, event, menuw)
def poll(self):
"""
plugin polling
"""
if self.playing:
self.timer += 1
if self.timer >= 4:
self.timer = 0
# try to connect to xine and check answer
if self.handle is None:
try:
self.handle = telnetlib.Telnet('127.0.0.1', 6789)
out = self.handle.read_until('\n', 0.1)
if out[-1] != '\n':
raise
except:
self.handle = None
logger.warning('Cannot telnet to xine at 127.0.0.1:6789')
# try to get xine time info
if self.handle is not None:
length = self.get_time('length')
elapsed = self.get_time('position')
if length and elapsed:
rc.post_event(Event('VIDEO_PLAY_INFO', arg=(elapsed, length)))
def error_handler(self):
"""
error handler if play doesn't work to send the end event and stop
the player
"""
rc.post_event(PLAY_END)
self.stop()
def poll(self):
"""
plugin polling
"""
if self.playing:
self.timer += 1
if self.timer >= 4:
self.timer = 0
# try to connect to xine and check answer
if self.handle is None:
try:
self.handle = telnetlib.Telnet("127.0.0.1", 6789)
out = self.handle.read_until("\n", 0.1)
if out[-1] != "\n":
raise
except:
self.handle = None
logger.warning("Cannot telnet to xine at 127.0.0.1:6789")
# try to get xine time info
if self.handle is not None:
length = self.get_time("length")
elapsed = self.get_time("position")
if length and elapsed:
rc.post_event(Event("VIDEO_PLAY_INFO", arg=(elapsed, length)))
def init_page(self):
self.screen_transition = skin.TRANSITION_PAGE
menu = self.menustack[-1]
if not menu:
return
# Create the list of main selection items (menu_items)
menu_items = []
first = menu.page_start
self.rows, self.cols = menu.items_per_page()
for choice in menu.choices[first : first+(self.rows*self.cols)]:
menu_items.append(choice)
self.rows, self.cols = menu.items_per_page()
self.menu_items = menu_items
if len(menu_items) == 0:
self.all_items = menu_items + [ MenuItem('Back', self.back_one_menu) ]
else:
self.all_items = menu_items
if not menu.selected in self.all_items:
menu.selected = self.all_items[0]
if not menu.choices:
menu.selected = self.all_items[0]
rc.post_event(MENU_PROCESS_END)
def init_page(self):
self.screen_transition = skin.TRANSITION_PAGE
menu = self.menustack[-1]
if not menu:
return
# Create the list of main selection items (menu_items)
menu_items = []
first = menu.page_start
self.rows, self.cols = menu.items_per_page()
for choice in menu.choices[first:first + (self.rows * self.cols)]:
menu_items.append(choice)
self.rows, self.cols = menu.items_per_page()
self.menu_items = menu_items
if len(menu_items) == 0:
self.all_items = menu_items + [
MenuItem('Back', self.back_one_menu)
]
else:
self.all_items = menu_items
if not menu.selected in self.all_items:
menu.selected = self.all_items[0]
if not menu.choices:
menu.selected = self.all_items[0]
rc.post_event(MENU_PROCESS_END)
def poll(self):
"""
stop everything when child is dead
"""
if not self.isAlive():
rc.post_event(self.stop_event())
self.stop()
def run(self):
logger.debug("run()")
while 1:
logger.debug("Record_Thread::run: mode=%s", self.mode)
if self.mode == "idle":
self.mode_flag.wait()
self.mode_flag.clear()
elif self.mode == "record":
rc.post_event(Event("RECORD_START", arg=self.prog))
logger.debug("Record_Thread::run: cmd=%s", self.command)
self.app = RecordApp(self.command)
logger.debug("app child pid: %s", self.app.child.pid)
while self.mode == "record" and self.app.isAlive():
self.autokill -= 0.5
time.sleep(0.5)
if self.autokill <= 0:
logger.debug("autokill timeout, stopping recording")
self.mode = "stop"
if self.app.isAlive():
logger.debug("Record_Thread::run: past wait!!")
self.app.kill()
rc.post_event(Event("RECORD_STOP", arg=self.prog))
logger.debug("Record_Thread::run: finished recording")
self.mode = "idle"
else:
self.mode = "idle"
time.sleep(0.5)
def _event_handler(self, event):
logger.log(9, '_event_handler(event=%s), event.arg=%r, event.context=%r, PluginInterface.detached=%r',
event, event.arg, event.context, PluginInterface.detached)
gui = audio.player.get()
if gui:
p = gui.player
if event == BUTTON:
if event.arg == 'FFWD':
p.eventhandler(Event('SEEK', arg='10', context='audio'))
elif event.arg == 'REW':
p.eventhandler(Event('SEEK', arg='-10', context='audio'))
elif event.arg == 'PAUSE':
p.eventhandler(Event('PLAY', context='audio'))
elif event.arg == 'STOP':
PluginInterface.detached = False
p.eventhandler(Event('STOP'))
elif event.arg == 'NEXT':
p.eventhandler(Event('PLAYLIST_NEXT', context='audio'))
elif event.arg == 'PREV':
p.eventhandler(Event('PLAYLIST_PREV', context='audio'))
elif plugin.isevent(event) == 'DETACH':
p.eventhandler(event)
self._detach()
elif plugin.isevent(event) == 'ATTACH':
self._attach()
p.eventhandler(event)
elif event == VIDEO_START:
PluginInterface.detached = False
p.eventhandler(Event('STOP'))
elif event == PLAY_START and gui.visible:
rc.post_event(plugin.event('ATTACH'))
def stop(self, cmd=''):
"""
stop the child
"""
rc.unregister(self.poll)
rc.unregister(self.stop)
if cmd and self.isAlive():
_debug_('sending exit command to app \"%r\"' % cmd)
self.write(cmd)
# wait for the app to terminate itself
for i in range(60):
if not self.isAlive():
break
time.sleep(0.1)
# kill the app
self.kill()
# Ok, we can use the OSD again.
if self.stop_osd:
osd.restart()
if self.is_video:
rc.post_event(Event(VIDEO_END))
def poll(self, menuw=None, arg=None):
"""
poll to check for devices
"""
changes = False
current_devices = util.list_usb_devices()
for d in current_devices:
try:
self.devices.remove(d)
except ValueError:
logger.debug('new device %s', d)
for device, message, action in config.USB_HOTPLUG:
if d == device:
pop = dialog.show_working_indicator(message)
os.system(action)
pop.hide()
break
else:
changes = True
for d in self.devices:
changes = True
logger.debug('removed device %s', d)
if changes:
rc.post_event(plugin.event('USB'))
self.devices = current_devices
def Stop(self):
self.mixer.stop()
self.xine.stop()
rc.app(self.prev_app)
rc.post_event(PLAY_END)
_debug_("IVTV_XINE_TV: Stopped '%s' app" % self.mode)
def poll(self, menuw=None, arg=None):
"""
poll to check for devices
"""
changes = False
current_devices = util.list_usb_devices()
for d in current_devices:
try:
self.devices.remove(d)
except ValueError:
logger.debug('new device %s', d)
for device, message, action in config.USB_HOTPLUG:
if d == device:
pop = dialog.show_working_indicator(message)
os.system(action)
pop.hide()
break
else:
changes = True
for d in self.devices:
changes = True
logger.debug('removed device %s', d)
if changes:
rc.post_event(plugin.event('USB'))
self.devices = current_devices
def poll(self, menuw=None, arg=None):
"""
poll to check for devices
"""
changes = False
current_devices = util.list_usb_devices()
for d in current_devices:
try:
self.devices.remove(d)
except ValueError:
_debug_('new device %s' % (d))
for device, message, action in config.USB_HOTPLUG:
if d == device:
pop = PopupBox(text=message)
pop.show()
os.system(action)
pop.destroy()
break
else:
changes = True
for d in self.devices:
changes = True
_debug_('removed device %s' % (d))
if changes:
rc.post_event(plugin.event('USB'))
self.devices = current_devices
def stop(self, cmd=''):
"""
stop the child
"""
logger.log( 9, 'ChildApp2.stop(cmd=%r)', cmd)
self.timer.stop()
rc.unregister(self.stop)
if cmd and self.isAlive():
self.write(cmd)
# wait for the app to terminate itself
for i in range(60):
if not self.isAlive():
break
time.sleep(0.1)
# kill the app
if self.isAlive():
self.kill()
# Ok, we can use the OSD again.
if self.stop_osd:
osd.restart()
if self.is_video:
rc.post_event(Event(VIDEO_END))
def __drawn(self, item):
if plugin.getbyname('osd'):
plugin.getbyname('osd').draw(('osd', None), self.osd)
# draw
self.osd.update()
# start timer
if self.duration and self.slideshow and not self.timer:
self.timer = kaa.OneShotTimer(self.signalhandler)
self.timer.start(self.duration)
# stop slideshow at the end if configured
try:
index = item.parent.play_items.index(item)+1
length = len(item.parent.play_items)
if index == length:
self.slideshow = config.IMAGEVIEWER_AUTOPLAY
# send information event to LCD2
rc.post_event(Event('IMAGE_VIEW_INFO', arg=(index, length, item.name)))
except Exception, why:
logger.warning('Invalid parent item: %s', why)
def change2m3u(self, arg=None, menuw=None):
myfile = file(os.path.join(config.FREEVO_CACHEDIR, 'changem3u.txt'),
'wb')
myfile.write(self.item.filename)
myfile.flush()
myfile.close()
rc.post_event(em.MENU_BACK_ONE_MENU)
def check_all(self):
"""
check all drives
"""
if rc.app():
# Some app is running, do not scan, it's not necessary
return
self.lock.acquire()
try:
for media in config.REMOVABLE_MEDIA:
last_status = media.drive_status
self.identify(media)
if last_status != media.drive_status:
_debug_('MEDIA: Status=%s' % media.drive_status, 2)
_debug_('Posting IDENTIFY_MEDIA event', 2)
if last_status == None:
rc.post_event(
plugin.event('IDENTIFY_MEDIA', arg=(media, True)))
else:
rc.post_event(
plugin.event('IDENTIFY_MEDIA', arg=(media, False)))
finally:
self.lock.release()
def run(self):
logger.debug('run()')
while 1:
logger.debug('Record_Thread::run: mode=%s', self.mode)
if self.mode == 'idle':
self.mode_flag.wait()
self.mode_flag.clear()
elif self.mode == 'record':
rc.post_event(Event('RECORD_START', arg=self.prog))
logger.debug('Record_Thread::run: cmd=%s', self.command)
self.app = RecordApp(self.command)
logger.debug('app child pid: %s', self.app.child.pid)
while self.mode == 'record' and self.app.isAlive():
self.autokill -= 0.5
time.sleep(0.5)
if self.autokill <= 0:
logger.debug('autokill timeout, stopping recording')
self.mode = 'stop'
if self.app.isAlive():
logger.debug('Record_Thread::run: past wait!!')
self.app.kill()
rc.post_event(Event('RECORD_STOP', arg=self.prog))
logger.debug('Record_Thread::run: finished recording')
self.mode = 'idle'
else:
self.mode = 'idle'
time.sleep(0.5)
def run(self):
logger.debug('run()')
while 1:
logger.debug('Record_Thread::run: mode=%s', self.mode)
if self.mode == 'idle':
self.mode_flag.wait()
self.mode_flag.clear()
elif self.mode == 'record':
rc.post_event(Event('RECORD_START', arg=self.prog))
logger.debug('Record_Thread::run: cmd=%s', self.command)
self.app = RecordApp(self.command)
logger.debug('app child pid: %s', self.app.child.pid)
while self.mode == 'record' and self.app.isAlive():
self.autokill -= 0.5
time.sleep(0.5)
if self.autokill <= 0:
logger.debug('autokill timeout, stopping recording')
self.mode = 'stop'
if self.app.isAlive():
logger.debug('Record_Thread::run: past wait!!')
self.app.kill()
rc.post_event(Event('RECORD_STOP', arg=self.prog))
logger.debug('Record_Thread::run: finished recording')
self.mode = 'idle'
else:
self.mode = 'idle'
time.sleep(0.5)
def __init__(self, app, debugname=None, doeslogging=0, stop_osd=2, callback_use_rc=True):
"""
Initialise ChildApp2
"""
logger.debug('ChildApp2.__init__(app=%r, debugname=%r, doeslogging=%r, stop_osd=%r)', app, debugname, doeslogging, stop_osd)
self.timer = kaa.Timer(self.poll)
self.timer.start(0.1)
rc.register(self.stop, True, rc.SHUTDOWN)
self.is_video = 0 # Be more explicit
if stop_osd == 2:
self.is_video = 1
rc.post_event(Event(VIDEO_START))
stop_osd = config.OSD_STOP_WHEN_PLAYING
self.stop_osd = stop_osd
if self.stop_osd:
osd.stop()
if hasattr(self, 'item'):
rc.post_event(Event(PLAY_START, arg=self.item))
# return status of the child
self.status = 0
# start the child
ChildApp.__init__(self, app, debugname, doeslogging, callback_use_rc)
def __change_state(self, new_state):
"""
Internal function to move to a new state.
If new_state is different to the current state, set self.state to
new_state and perform any state initialisation for the new state.
"""
if self.state == new_state:
# No change in state nothing todo!
return
_debug_('Changing state from %s to %s' % (self.state, new_state))
self.state = new_state
# State Initialisation code
if self.state == STATE_IDLE:
rc.app(None)
rc.post_event(PLAY_END)
self.udp_receiver.send_events = False
elif self.state == STATE_TUNING:
self.start_slave_server_at_end = True
elif self.state == STATE_BUFFERING:
self.wait_for_data_count = WAIT_FOR_DATA_COUNT
elif self.state == STATE_PLAYING:
self.slave_server.reader_at_end = self.start_slave_server_at_end
self.slave_server.end_offset = self.udp_receiver.average_pps * WAIT_FOR_DATA_COUNT * 188
self.mrl_index = 0
self.app = childapp.ChildApp2(self.command)
self.start_slave_server_at_end = False
self.__draw_state_screen()
def error_handler(self):
"""
error handler if play doesn't work to send the end event and stop
the player
"""
rc.post_event(PLAY_END)
self.stop()
def process_data(self):
str_arg = ''
command = None
_debug_("Data received: %s" % str(self.data), 2)
str_cmd = self.data[:4]
if str_cmd in ('VOL-', 'VOL+', 'VOLM', 'MAIN', 'STAT'):
command = self.cmds.get(str_cmd, '')
if command:
_debug_('Event Translation: "%s" -> "%s"' % (str_cmd, command))
if str_cmd in ('VOL-', 'VOL+'):
self.rc.post_event(
em.Event(command, arg=self.mixer_default_step))
else:
self.rc.post_event(em.Event(command))
elif str_cmd == 'TEXT':
str_arg = self.data[4:]
for letter in str_arg:
command = self.rc.key_event_mapper(letter)
if command:
_debug_('Event with arg Translation: "%s" -> "%s %s"' %
(self.data, command, letter))
self.rc.post_event(command)
elif str_cmd == 'MSND':
self.menu_client_waiting = True
elif str_cmd == 'MITM':
str_arg = self.data[4:]
try:
pos = int(str_arg)
menu = self.menuw.menustack[-1]
max = len(menu.choices)
if pos < max:
menu.selected = menu.choices[pos]
self.rc.post_event(em.MENU_SELECT)
else:
_debug_('Menu index too high!: %s (max=%s)' %
(pos, max - 1))
except ValueError:
_debug_('Menu index sent: %s' % str_arg)
pass
else:
command = self.rc.key_event_mapper(self.cmds.get(self.data, ''))
if command:
_debug_('Event Translation: "%s" -> "%s"' %
(self.data, command))
self.rc.post_event(command)
if command and self.osd_message:
_debug_('OSD Event: "%s"' % (command))
rc.post_event(
em.Event(em.OSD_MESSAGE, arg=_('BT event %s' % command)))
self.data = ''
def _timer_handler(self):
if self.active:
logger.info('Timeout reached without an event, posting events now.')
for e in config.AUTOSTART_EVENTS:
rc.post_event(Event(e))
self.event.unregister()
self.timer.stop()
self.active = False
def poll(self):
"""
stop everything when child is dead
"""
logger.log( 8, 'ChildApp2.poll()')
if not self.isAlive():
rc.post_event(self.stop_event())
self.stop()
def eventhandler(self, event=None, arg=None):
"""
eventhandler to simulate hide/show of mpav
"""
_debug_('eventhandler(event=%r, arg=%r)' % (event.name, arg), 2)
if event == 'CHANGE_MODE':
self.toggle_view()
return True
if event == 'TOGGLE_TITLE':
self.title = not self.title and self.item.name or ''
_debug_('title=%s' % (self.title), 2)
self.visual.set_title(self.title)
return True
if event == 'TOGGLE_MESSAGE':
self.message = not self.message and self.item_info(
self.message_fmt) or ''
_debug_('info=%s' % (self.message), 2)
self.visual.set_message(self.message)
return True
if event == 'NEXT_VISUAL':
self.vis_mode += 1
if self.vis_mode > 9: self.vis_mode = -1
_debug_('vis_mode=%s' % (self.vis_mode), 2)
self.visual.set_visual(self.vis_mode)
rc.post_event(
Event(OSD_MESSAGE, arg=_('FXMODE is %s' % self.vis_mode)))
return True
if event == 'CHANGE_VISUAL':
self.vis_mode = event.arg
if self.vis_mode < -1: self.vis_mode = -1
if self.vis_mode > 9: self.vis_mode = 9
_debug_('vis_mode=%s' % (self.vis_mode), 2)
self.visual.set_visual(self.vis_mode)
rc.post_event(
Event(OSD_MESSAGE, arg=_('FXMODE is %s' % self.vis_mode)))
return True
if self.visual and self.view == FULL:
if event == OSD_MESSAGE:
self.visual.set_info(event.arg)
return True
if self.passed_event:
self.passed_event = False
return False
self.passed_event = True
if event != PLAY_END:
return self.player.eventhandler(event)
return False
def shuntItemInCart(self, item):
''' Move an image item into or out of the shopping cart
'''
if self.cart != [] and item in self.cart:
self.cart.remove(item)
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Removed Item from Cart')))
else:
self.cart.append(item)
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Added Item to Cart')))
def run(self):
while 1:
if DEBUG: print('Record_Thread::run: mode=%s' % self.mode)
if self.mode == 'idle':
self.mode_flag.wait()
self.mode_flag.clear()
elif self.mode == 'record':
rc.post_event(Event('RECORD_START', arg=self.prog))
if DEBUG: print 'Record_Thread::run: started recording'
fc = FreevoChannels()
if DEBUG: print 'CHAN: %s' % fc.getChannel()
(v_norm, v_input, v_clist, v_dev) = config.TV_SETTINGS.split()
v = tv.ivtv.IVTV(v_dev)
v.init_settings()
vg = fc.getVideoGroup(self.prog.tunerid, False)
if DEBUG: print 'Setting Input to %s' % vg.input_num
v.setinput(vg.input_num)
if DEBUG: print 'Setting Channel to %s' % self.prog.tunerid
fc.chanSet(str(self.prog.tunerid), False)
if DEBUG: v.print_settings()
now = time.time()
stop = now + self.prog.rec_duration
time.sleep(2)
v_in = open(v_dev, 'r')
v_out = open(self.prog.filename, 'w')
while time.time() < stop:
buf = v_in.read(CHUNKSIZE)
v_out.write(buf)
if self.mode == 'stop':
break
v_in.close()
v_out.close()
v.close()
v = None
self.mode = 'idle'
rc.post_event(Event('RECORD_STOP', arg=self.prog))
if DEBUG: print('Record_Thread::run: finished recording')
else:
self.mode = 'idle'
time.sleep(0.5)
def redraw(self):
"""
Request that the dialog be redrawn.
"""
#_stack_('Processing events? %r' % self.processing_event )
if self.processing_event:
self.force_redraw = True
else:
rc.post_event(event.Event(REDRAW_DIALOG, self))
def stdout_cb(self, line):
"""
parse the stdout of the mplayer process
"""
# show connection status for network play
if self.item.network_play:
if line.find('Opening audio decoder') == 0:
self.osd.clearscreen(self.osd.COL_BLACK)
self.osd.update()
elif (line.startswith('Resolving ') or \
line.startswith('Connecting to server') or \
line.startswith('Cache fill:')) and \
line.find('Resolving reference to') == -1:
if line.startswith('Connecting to server'):
line = 'Connecting to server'
self.osd.clearscreen(self.osd.COL_BLACK)
self.osd.drawstringframed(
line, config.OSD_OVERSCAN_X + 10,
config.OSD_OVERSCAN_Y + 10,
self.osd.width - 2 * (config.OSD_OVERSCAN_X + 10), -1,
self.osdfont, self.osd.COL_WHITE)
self.osd.update()
# current elapsed time
if line.find("A:") == 0:
m = self.RE_TIME(line)
if hasattr(m,
'group') and self.item.elapsed != int(m.group(1)) + 1:
self.item.elapsed = int(m.group(1)) + 1
for p in self.elapsed_plugins:
p.elapsed(self.item.elapsed)
# exit status
elif line.find("Exiting...") == 0:
m = self.RE_EXIT(line)
if m:
self.exit_type = m.group(1)
# this is the first start of the movie, parse infos
elif not self.item.elapsed:
for p in self.stdout_plugins:
p.stdout(line)
if self.check_audio:
if line.find('MPEG: No audio stream found -> no sound') == 0:
# OK, audio is broken, restart without -alang
self.check_audio = 2
self.item.mplayer_audio_broken = True
rc.post_event(Event('AUDIO_ERROR_START_AGAIN'))
if self.RE_START(line):
if self.check_audio == 1:
# audio seems to be ok
self.item.mplayer_audio_broken = False
self.check_audio = 0
def cd_backup(self, arg, menuw=None):
device, type = arg
self.rip_thread = main_backup_thread(device=device, rip_format=type)
self.rip_thread.start()
# delete the choose format menu
menuw.delete_menu()
# delete submenu
menuw.delete_submenu()
# show message
rc.post_event(Event(OSD_MESSAGE, _('Ripping started')))
def cd_backup(self, arg, menuw=None):
device, type = arg
self.rip_thread = main_backup_thread(device=device, rip_format=type)
self.rip_thread.start()
# delete the choose format menu
menuw.delete_menu()
# delete submenu
menuw.delete_submenu()
# show message
rc.post_event(Event(OSD_MESSAGE, _('Ripping started')))
def Stop(self):
""" Stop the xine player """
logger.debug('XineIvtv.Stop()')
dialog.disable_overlay_display()
self.mixer.Stop()
self.tuner.Stop()
self.xine.Stop()
rc.remove_app(self)
rc.post_event(PLAY_END)
logger.debug('Stopped %r app', self.mode)
def Stop(self):
""" Stop the xine player """
logger.debug('XineIvtv.Stop()')
dialog.disable_overlay_display()
self.mixer.Stop()
self.tuner.Stop()
self.xine.Stop()
rc.remove_app(self)
rc.post_event(PLAY_END)
logger.debug('Stopped %r app', self.mode)
def eventhandler(self, event=None, menuw=None, arg=None):
"""
eventhandler to handle the new events
"""
for r in config.NEW_EVENTS:
if event == r[0]:
system(r[1])
if len(r) > 2:
rc.post_event(Event(OSD_MESSAGE, arg=r[2]))
return True
def eventhandler(self, event=None, menuw=None, arg=None):
"""
eventhandler to handle the new events
"""
for r in config.NEW_EVENTS:
if event == r[0]:
system(r[1])
if len(r) > 2:
rc.post_event(Event(OSD_MESSAGE, arg=r[2]))
return True
def process_data(self):
str_arg = ''
command = None
logger.log( 9, "Data received: %s", str(self.data))
str_cmd = self.data[:4]
if str_cmd in ('VOL-', 'VOL+', 'VOLM', 'MAIN', 'STAT'):
command = self.cmds.get(str_cmd, '')
if command:
logger.debug('Event Translation: "%s" -> "%s"', str_cmd, command)
if str_cmd in ('VOL-', 'VOL+'):
self.rc.post_event(em.Event(command, arg=config.MIXER_VOLUME_STEP))
else:
self.rc.post_event(em.Event(command))
elif str_cmd == 'TEXT':
str_arg = self.data[4:]
for letter in str_arg:
command = self.rc.key_event_mapper(letter)
if command:
logger.debug('Event with arg Translation: "%s" -> "%s %s"', self.data, command, letter)
self.rc.post_event(command)
elif str_cmd == 'MSND':
self.menu_client_waiting = True
logger.debug('Client asked for menu')
elif str_cmd == 'MITM':
str_arg = self.data[4:]
try:
pos = int(str_arg)
menu = self.menuw.menustack[-1]
max = len(menu.choices)
if pos < max:
menu.selected = menu.choices[pos]
self.rc.post_event(em.MENU_SELECT)
else:
logger.debug('Menu index too high!: %s (max=%s)', pos, max - 1)
except ValueError:
logger.debug('Menu index sent: %s', str_arg)
pass
else:
command = self.rc.key_event_mapper(self.cmds.get(self.data, ''))
if command:
logger.debug('Event Translation: "%s" -> "%s"', self.data, command)
self.rc.post_event(command)
if command and self.osd_message:
logger.debug('OSD Event: "%s"', command)
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('BT event %s' % command)))
self.data=''
def play(self, arg=None, menuw=None):
self.elapsed = 0
if not self.menuw:
self.menuw = menuw
self.player = PodCastPlayerGUI(self, menuw) #LastFM
error = self.player.play()
if error and menuw:
AlertBox(text=error).show()
rc.post_event(rc.PLAY_END)
def addToCart(self, arg=None, menuw=None):
if hasattr(self.item, 'subitems') and self.item.subitems:
for s in self.item.subitems:
self.cart.append(s)
else:
self.cart.append(self.item)
if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
rc.post_event(em.MENU_BACK_ONE_MENU)
else:
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Added to Cart')))
def removeFromCart(self, arg=None, menuw=None):
if hasattr(self.item, 'subitems') and self.item.subitems:
for s in self.item.subitems:
self.cart.remove(s)
else:
self.cart.remove(self.item)
if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
rc.post_event(em.MENU_BACK_ONE_MENU)
else:
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Removed from Cart')))
def addToCart(self, arg=None, menuw=None):
if hasattr(self.item, 'subitems') and self.item.subitems:
for s in self.item.subitems:
self.cart.append(s)
else:
self.cart.append(self.item)
if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
rc.post_event(em.MENU_BACK_ONE_MENU)
else:
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Added to Cart')))
def removeFromCart(self, arg=None, menuw=None):
if hasattr(self.item, 'subitems') and self.item.subitems:
for s in self.item.subitems:
self.cart.remove(s)
else:
self.cart.remove(self.item)
if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
rc.post_event(em.MENU_BACK_ONE_MENU)
else:
rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Removed from Cart')))
def shuntItemInCart(self, item):
''' Move an image item into or out of the shopping cart
'''
if self.cart != [] and item in self.cart:
self.cart.remove(item)
rc.post_event(
em.Event(em.OSD_MESSAGE, arg=_('Removed Item from Cart')))
else:
self.cart.append(item)
rc.post_event(em.Event(em.OSD_MESSAGE,
arg=_('Added Item to Cart')))
def play(self, arg=None, menuw=None):
logger.debug("%s.play(arg=%r, menuw=%r)", self.__module__, arg, menuw)
self.elapsed = 0
if not self.menuw:
self.menuw = menuw
self.player = PodCastPlayerGUI(self, menuw) # LastFM
error = self.player.play()
if error and menuw:
AlertBox(text=error).show()
rc.post_event(rc.PLAY_END)
def play(self, arg=None, menuw=None):
logger.debug('%s.play(arg=%r, menuw=%r)', self.__module__, arg, menuw)
self.elapsed = 0
if not self.menuw:
self.menuw = menuw
self.player = PodCastPlayerGUI(self, menuw) #LastFM
error = self.player.play()
if error and menuw:
AlertBox(text=error).show()
rc.post_event(rc.PLAY_END)
def poll(self):
try:
conn,addr = self.sock.accept()
data = conn.recv(300) # 300 is max in specification
if data:
if data[:5] == '@CALL':
rc.post_event(Event(OSD_MESSAGE, arg=_('Call: %s') % data[5:-1]))
else:
rc.post_event(Event(OSD_MESSAGE, arg=_('Message: %s') % data[:-1]))
conn.close()
except:
pass
def stepAudioBalance(self, s):
"""Modify the audio balance by the given amount, then
show the current value on the OSD.
"""
b = self.getAudioBalance()
b += s
if b < 0:
b = 0
if b > 1:
b = 1
self.setAudioBalance(b)
msg = "Input Audio: %d%%" % int(b * 100 + 0.5)
rc.post_event(Event(OSD_MESSAGE, arg=msg))
def eventhandler(self, event):
if event in (INPUT_LEFT, INPUT_UP):
if self.b0.selected:
self.b0.toggle_selected()
self.b2.toggle_selected()
elif self.b1.selected:
self.b1.toggle_selected()
self.b0.toggle_selected()
else:
self.b1.toggle_selected()
self.b2.toggle_selected()
self.draw()
return
elif event in (INPUT_RIGHT, INPUT_DOWN):
if self.b0.selected:
self.b1.toggle_selected()
self.b0.toggle_selected()
elif self.b1.selected:
self.b1.toggle_selected()
self.b2.toggle_selected()
else:
self.b0.toggle_selected()
self.b2.toggle_selected()
self.draw()
return
elif event == INPUT_EXIT:
self.destroy()
elif event == INPUT_ENTER:
if self.b0.selected:
s = xmlrpclib.ServerProxy(config.RPCHOST)
if (s.d.is_active(self.globalHash) == 1) ^ (s.d.is_hash_checking(self.globalHash) == 1):
s.d.stop(self.globalHash)
else:
s.d.start(self.globalHash)
rc.post_event(em.MENU_BACK_ONE_MENU)
self.destroy()
elif self.b1.selected:
s = xmlrpclib.ServerProxy(config.RPCHOST)
s.d.erase(self.globalHash)
self.destroy()
rc.post_event(em.MENU_BACK_ONE_MENU)
else:
self.destroy()
else:
return self.parent.eventhandler(event)
def check_all(self):
""" Check all drives """
if not skin.active():
# Some app is running, do not scan, it's not necessary
return
self.lock.acquire()
try:
for media in config.REMOVABLE_MEDIA:
self.identify(media)
if media.get_drive_status_changed():
logger.debug('posting IDENTIFY_MEDIA event %r', media.drive_status_text(media.drive_status))
rc.post_event(plugin.event('IDENTIFY_MEDIA', arg=(media, media.drive_status)))
finally:
self.lock.release()
def play(self, arg=None, menuw=None):
logger.debug('%s.play(arg=%r, menuw=%r)', self.__class__, arg, menuw)
self.elapsed = 0
if not self.menuw:
self.menuw = menuw
menuw = self.menuw
self.player = PlayerGUI(self, menuw)
error = self.player.play()
if error and menuw:
AlertBox(text=error).show()
rc.post_event(rc.PLAY_END)
def findNextProgramHandler(self, result):
""" Handles the result from the findNextProgram call """
logger.log( 9, 'findNextProgramHandler(result=%r)', result)
(status, self.next_program) = result
if not status:
return
now = time.time()
logger.log( 9, 'now=%s next=%s ', time.strftime('%T', time.localtime(now)), self.next_program)
self.seconds_to_next = self.next_program.start - config.TV_RECORD_PADDING_PRE - int(now + 0.5)
logger.log( 9, 'next recording in %s secs', self.seconds_to_next)
self.vdev = self.getVideoForChannel(self.next_program.channel_id)
self.tv_lockfile = os.path.join(config.FREEVO_CACHEDIR, 'record.'+self.vdev.split('/')[-1])
#print 'now=%s next=%s secs=%s file=%s' % (time.strftime('%T', time.localtime(now)),
# self.next_program, self.seconds_to_next, os.path.basename(self.tv_lockfile))
if os.path.exists(self.pending_lockfile):
self.announced = False
if os.path.exists(self.tv_lockfile):
os.remove(self.pending_lockfile)
logger.debug('%r lockfile removed tv lock detected', self.pending_lockfile)
elif self.seconds_to_next < -self.seconds_before_start:
os.remove(self.pending_lockfile)
logger.debug('%r lockfile removed recording in-progress', self.pending_lockfile)
else:
if os.path.exists(self.tv_lockfile):
logger.debug('%r not creating tv lock detected', self.pending_lockfile)
return
if self.seconds_to_next < 0:
logger.debug('%r not creating recording in-progress', self.pending_lockfile)
return
# announce 120 seconds before recording is due to start
# stop the player 60 seconds before recording is due to start
if self.seconds_to_next <= self.seconds_before_start:
open(self.pending_lockfile, 'w').close()
logger.debug('%r lockfile created', self.pending_lockfile)
self.stopVideoInUse(self.vdev)
self.stopRadioInUse(self.rdev)
logger.debug('stopped video or radio player')
elif self.seconds_to_next <= self.seconds_before_announce:
if not self.announced:
rc.post_event(Event(OSD_MESSAGE, arg=_('A recording will start in a few minutes')))
logger.debug('announced')
self.announced = True
def run(self):
logger.log( 9, 'Record_Thread.run()')
while 1:
logger.debug('mode=%s', self.mode)
if self.mode == 'idle':
self.mode_flag.wait()
self.mode_flag.clear()
elif self.mode == 'record':
rc.post_event(Event('RECORD_START', arg=self.prog))
fc = FreevoChannels()
logger.debug('channel %s', fc.getChannel())
self.vg = fc.getVideoGroup(self.prog.tunerid, False)
v = tv.ivtv.IVTV(self.vg.vdev)
v.init_settings()
logger.debug('Using video device=%r', self.vg.vdev)
logger.debug('Setting Channel to %r', self.prog.tunerid)
fc.chanSet(str(self.prog.tunerid), False)
logger.debug('command %r', self.command)
self.app = RecordApp(self.command)
logger.debug('command pid: %s', self.app.child.pid)
while self.mode == 'record' and self.app.isAlive():
self.autokill -= 0.5
time.sleep(0.5)
if self.autokill <= 0:
logger.debug('autokill timeout, stopping recording')
self.mode = 'stop'
if self.app.isAlive():
# might not want to do this is PDC is valid, programme may be delayed
logger.debug('past wait!!')
self.app.kill()
rc.post_event(Event('RECORD_STOP', arg=self.prog))
logger.debug('finished recording')
self.mode = 'idle'
else:
self.mode = 'idle'
time.sleep(0.5)
def delete_submenu(self, refresh=True, reload=False, osd_message=''):
"""
Delete the last menu if it is a submenu. Also refresh or reload the
new menu if the attributes are set to True. If osd_message is set,
this message will be send if the current menu is no submenu
"""
if len(self.menustack) > 1 and hasattr(self.menustack[-1], 'is_submenu') and \
self.menustack[-1].is_submenu:
if refresh and reload:
self.back_one_menu(arg='reload')
elif refresh:
self.back_one_menu()
else:
self.delete_menu()
elif len(self.menustack) > 1 and osd_message:
rc.post_event(Event(OSD_MESSAGE, arg=osd_message))
def stop_saver(self):
logger.debug('stop screensaver')
self.screensaver_showing = FALSE
if self.saver_type == 'xscreensaver':
os.system('%s -exit' % self.arg2)
elif self.saver_type == 'script':
os.system('%s' % self.arg2)
elif self.saver_type == 'ssr':
rc.post_event(em.STOP)
elif self.saver_type == 'fxd':
rc.post_event(em.STOP)
else:
logger.debug('Unknown saver type to stop.')
time.sleep(1)
self.osd.update()
