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: _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 __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 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 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 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 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()