def __init__(self, manager, path, size): self.name = 'vlc' self.app_mode = 'tv' self.app = None self.adapter_in_use = -1 self.fc = FreevoChannels() self.path = path self.size = size self.buffer = ring_buffer.RingBuffer(size, path) self.last_channel = None self.subtitles = False self.paused = False self.stop_time = 0 self.state = STATE_IDLE self.manager = manager self.udp_receiver = UDPReceiver(self.buffer, WAIT_FOR_DATA_TIMEOUT) self.slave_server = SlaveServer(self.buffer, self) self.fill = 0 self.cur_audio = None self.cur_sub = None self.cur_audiodev = None self.lastchan = None self.timer = kaa.Timer(self.__update_data_from_vlc) self.timer_start = kaa.OneShotTimer( self.__update_data_from_vlc) self.timer_disablebuffering = kaa.OneShotTimer( self.disable_buffering) if hasattr(config, 'LIVE_PAUSE_BUFFER_TIMEOUT'): self. buffering_timeout=config.LIVE_PAUSE_BUFFER_TIMEOUT else: # Disable after 5min if not LIVE_PAUSE_BUFFERING_TIMEOUT self.buffering_timeout= 5 * 60 # Create the command used to start vlc. # NOTE: We add the slave server MRL twice so that we can toggle between # them, this allows use to effectively reset vlc rendering pipeline and # make it possible to seek quickly. self.command = [ '--prio=%s' % config.MPLAYER_NICE ] + \ config.VLC_COMMAND.split(' ') + \ [ '--intf', 'rc' ] + \ ['--no-interact','--rc-fake-tty'] + \ [ '--sub-filter' ,'marq' ] + \ [ '--marq-marquee' ,'Playing' ] + \ [ '--marq-position','4'] + \ [ '--fullscreen', self.slave_server.get_vlc_mrl(), self.slave_server.get_vlc_mrl()] if not rc.PYLIRC and '--no-lirc' in self.command: self.command.remove('--no-lirc') self.udp_receiver.start() self.slave_server.start()
def __init__(self, device, channel, start, stop, url): self.device = device self.channel = channel self.start = start self.stop = stop self.url = url self.rec_id = None self.id = Schedule.__next Schedule.__next += 1 # internal timer self.timer = { 'start': kaa.OneShotTimer(self._start), 'stop': kaa.OneShotTimer(self._stop) } self._schedule()
def __init__(self): InputPlugin.__init__(self) self.config = freevo.config.input.plugin.joystick self.device_name = self.config.device blocked = self.get_resources('JOYSTICK') if len(blocked) != 0: # FIXME maybe different joysticks possible? log.error("Joystick is allready used, can't start joystick plugin") return for mapping in self.config.events: self.KEYMAP[mapping.input] = mapping.event try: self.joyfd = os.open(self.device_name, os.O_RDONLY | os.O_NONBLOCK) except OSError: # reason = 'Unable to open %s' % self.device_name log.error('Could not open joystick interface (%s)' % self.device_name) self.free_resources() return self.socket_dispatcher = kaa.IOMonitor(self.handle) self.socket_dispatcher.register(self.joyfd) self.timer = kaa.OneShotTimer(self.axis) self.movement = {} self.events = {}
def reschedule(self): """ Reschedule all recordings. """ if self.locked: # system busy, call again later kaa.OneShotTimer(self.reschedule).start(0.1) yield False self.locked = True # get current time (UTC) ctime = int(time.time()) # remove old recorderings self.recordings = filter(lambda r: r.start > ctime - 60*60*24*7, self.recordings) # run the scheduler to attach devices to recordings yield scheduler.schedule(self.recordings) # sort by start time self.recordings.sort(lambda l, o: cmp(l.start,o.start)) # save schedule self.save_schedule() self.print_schedule() # Schedule recordings on recorder for the next SCHEDULE_TIMER seconds. log.info('schedule recordings') for r in self.recordings: if r.start < ctime + SCHEDULE_TIMER and r.status == SCHEDULED: r.schedule() self.locked = False yield True
def main(): tvserver.connect('192.168.2.4:7600') yield tvserver.wait() if 0: yield kaa.epg.update() yield tvserver.favorites.update() if 0: for r in tvserver.recordings: print r if 1: t = int(time.time()) yield tvserver.recordings.schedule('test', 'Das Erste', 10, t + 4, t + 10, start_padding=0, stop_padding=0) if 0: yield server.recording_remove(2) if 0: print tvserver.favorites if 0: print( yield tvserver.favorites.add(u'Tagesschau', ['Das Erste'], 50, [0, 1, 2, 3, 4, 5, 6], [u'20:00-20:00'], False, False)) if 0: print(yield tvserver.favorites.remove(0)) if 0: print(yield tvserver.favorites.modify(0, priority=20)) if 0: print(yield kaa.epg.search(title=kaa.epg.QExpr('like', u'tagesschau'))) kaa.OneShotTimer(sys.exit, 0).start(1)
def __init__(self): """ init the osd """ super(PluginInterface, self).__init__() kaa.EventHandler(self.show).register([freevo.OSD_MESSAGE]) self.widget = None self.hide_timer = kaa.OneShotTimer(self.hide)
def __init__(self, dialog): import pygame.time self.dialog = dialog self.state = 'running' self.timer = kaa.OneShotTimer(self.__update_dialog) self.delay = self.dialog.update_interval self.timer.start(self.delay) self.clock = pygame.time.Clock()
def __init__(self): """ create an image viewer application """ capabilities = (freevo.CAPABILITY_TOGGLE, freevo.CAPABILITY_FULLSCREEN) super(ImageViewer, self).__init__('image', capabilities) self.slideshow = False self.sshow_timer = kaa.OneShotTimer(self.slideshow_next) self.signals['stop'].connect_weak(self.application_stop)
def _beacon_update(self, item): """ Mark item as changed to be updated in the db. Called by Item objects """ if not self._changed: # register timer to do the changes kaa.OneShotTimer(self._beacon_update_all).start(0.1) self._changed.append(item)
def __init__(self): self._current_group = None self._current_cfg_path = [], [] self._filter_changed_timer = kaa.OneShotTimer(self.filter_changed_timeout_handler) gladefile = os.path.dirname(os.path.abspath(__file__)) + '/kaaconf-editor.glade' self.xml = gtk.glade.XML(gladefile, 'main') handlers = { 'on_toolbar_open_clicked': self.open_handler, 'on_toolbar_save_clicked': self.save_handler, 'on_toolbar_quit_clicked': self.exit_handler, 'on_main_delete_event': self.exit_handler, 'on_entry_filter_changed': self.filter_changed_handler, 'on_button_clear_clicked': self.button_clear_handler, } self.xml.signal_autoconnect(handlers) grouptree = self.xml.get_widget('tree-groups') grouptree.connect('row-activated', self.tree_row_activated_handler) grouptree.connect('cursor-changed', self.tree_cursor_changed_handler) treestore = gtk.TreeStore(gtk.gdk.Pixbuf, str) grouptree.set_model(treestore) col = gtk.TreeViewColumn() cr = gtk.CellRendererPixbuf() col.pack_start(cr, expand = False) col.add_attribute(cr, 'pixbuf', 0) cr = gtk.CellRendererText() col.pack_start(cr) col.add_attribute(cr, 'text', 1) grouptree.append_column(col) grouptree.set_search_column(1) vartree = self.xml.get_widget('tree-variables') vartree.connect('cursor-changed', self.list_cursor_changed_handler) liststore = gtk.ListStore(str, gobject.TYPE_PYOBJECT) vartree.set_model(liststore) cr = gtk.CellRendererText() col = gtk.TreeViewColumn('Name', cr, text = 0) col.set_reorderable(True) col.set_sort_column_id(0) col.set_min_width(150) col.set_resizable(True) vartree.append_column(col) cr = ProxyCellRenderer() cr.connect('changed', self.variable_changed) col = gtk.TreeViewColumn('Value', cr, value = 1) vartree.append_column(col) self._group_tree = grouptree self._var_tree = vartree
def search(self, items): if self.server is None: self.server = xmlrpclib.ServerProxy( "http://api.opensubtitles.org/xml-rpc") self.session = self.server.LogIn("", "", "en", "OS Test User Agent") self.token = self.session["token"] kaa.OneShotTimer(self.disconnect).start(20) try: return self.server.CheckMovieHash(self.token, items) except Exception, e: return None
def __init__(self, text, icon=None): """ Create a new instance. @param text: Text to display in the button. @param icon: Optional image filename to be displayed. """ super(ButtonModel, self).__init__() self.text = text self.icon = icon self.pressed = False self.signals['pressed'] = kaa.Signal() self.pressed_timer = kaa.OneShotTimer(self.__unpress)
def check_favorites_and_reschedule(self): """ Update recordings based on favorites and epg. """ if self.locked: # system busy, call again later kaa.OneShotTimer(self.check_favorites_and_reschedule).start(0.1) yield False self.locked = True yield epg.check(self.recordings, self.favorites) self.locked = False self.reschedule() yield True
def __init__(self): """ Create a new instance. """ super(GraphicsDisplay, self).__init__(True) self.current_dialog = None self.current_time_details = None self.waiting = { dialogs.Dialog.NORMAL_PRIORITY: None, dialogs.Dialog.LOW_PRIORITY: None } self.hide_dialog_timer = kaa.OneShotTimer(self.__hide_dialog) self.volume_dialog = None
def _connect(self): """ Connect to the server and init the connection. """ if self._connected: yield False self.socket = kaa.Socket() try: yield self.socket.connect((self._server, self._port)) except Exception, e: # try again later log.error('LCDproc connection error; will try again later') kaa.OneShotTimer(self._connect).start(10) yield False
def changed(dev, prop): print "device modified" print " UID: %s" % dev.udi if prop.get('volume.mount_point') == dev.prop.get('volume.mount_point'): return if prop.get('volume.mount_point'): print " Volume mounted to: %s" % prop.get('volume.mount_point') kaa.OneShotTimer(dev.mount, True).start(1) # kaa.OneShotTimer(dev.eject).start(1) else: print " Volume unmounted" print
def __init__(self, rc): """ Init the mouse event handler """ global dialog import dialog self.rc = rc pgh = get_pygame_handler() pgh.register_handler(pygame.locals.MOUSEMOTION, self.__process_mouse_motion) pgh.register_handler(pygame.locals.MOUSEBUTTONDOWN, self.__process_mouse_btn_down) pgh.register_handler(pygame.locals.MOUSEBUTTONUP, self.__process_mouse_btn_up) self.hide_mouse_timer = kaa.OneShotTimer(self.__hide_mouse)
def _beacon_update(self, item): """ Update item in next main loop interation. """ if not self.status == CONNECTED: return if not item._beacon_id: # Item has no beacon id, request the data before # schedule the update. item.scan().connect(self._beacon_update, item).ignore_caller_args = True return if not self._changed: # register timer to do the changes kaa.OneShotTimer(self._beacon_update_all).start(0.1) self._changed.append(item)
def eventhandler(self, event): """ Handle events from Freevo. """ if event.source == 'user': # user generated event (key/button), reset timeout counter self.counter = 0 if (event.source == 'user' and self._mode == AUTO) or \ (self._mode == USER and event == freevo.DPMS_BLANK_SCREEN): # screen is blank right now, restore it self._mode = OFF self.xset('dpms force on s reset') kaa.OneShotTimer(self.xset, '-dpms s off').start(1) self.timer.start(60) return if event == freevo.DPMS_BLANK_SCREEN: # event to turn off the monitor self._mode = USER self.xset('dpms force off') self.timer.stop()
def __init__(self, tmpdir, config_dir, scheduler=None): self.next_client_id = 0 self.clients = [] self.jobs = [] self._delayed_jobs = {} self._timer = kaa.OneShotTimer(self.step) self._ipc = kaa.rpc.Server(os.path.join(tmpdir, 'socket')) self._ipc.signals['client-connected'].connect(self.client_connect) self._ipc.register(self) # Load configuration for scheduler settings. We sync the config file # if necessary here instead of Server beacon-daemon forks and starts # Thumbnailer first. If we synced in Server instead, because we are # watching the config, we'd get notified of the change if the config # needed syncing, causing us to revert any run-time scheduler change. config.load(os.path.join(config_dir, 'config'), sync=True) config.watch() if scheduler: config.scheduler.policy = scheduler # video module self.videothumb = VideoThumb(self, config)
def new_device(media): print 'new', media kaa.OneShotTimer(media.eject).start(5)
def test_OneShotTimer(arg): result.append(arg) def test_Timer(arg): result.append(arg) class Cls(object): def meth(self, arg): result.append(arg) result = [] kaa.OneShotTimer(test_OneShotTimer, 42).start(0) kaa.main.step() test(result, [42]) result = [] kaa.OneShotTimer(Cls().meth, 42).start(0) kaa.main.step() test(result, [42]) result = [] kaa.WeakOneShotTimer(Cls().meth, 42).start(0) kaa.main.step() test(result, []) result = [] cb = Cls().meth
name = Unicode(string.join(sys.argv[2:])) title = name channel = "ANY" dow = "ANY" mod = "ANY" priority = 0 allowDuplicates = False onlyNew = True (result, msg) = addEditedFavorite(name, title, channel, dow, mod, priority, allowDuplicates, onlyNew) if not result: # it is important to show the user this error, # because that means the favorite is removed, # and must be created again logger.warning('Save Failed, favorite was lost: %s', msg) else: logger.debug('Ok!') (result, response) = updateFavoritesSchedule() logger.debug('%r', response) else: print 'no data' else: print 'function %r not found' % (function) raise SystemExit kaa.OneShotTimer(shutdown, 'bye', time.time()).start(20) kaa.main.run()
def go(w, h): global screen screen = lcd.create_screen('test') screen.widget_add('string', 1, 1, 'hiƤ') kaa.OneShotTimer(g2).start(2)
def __init__(self): self.timer = kaa.OneShotTimer(gui.set_active, False)
class Test(): @kaa.threaded(kaa.GOBJECT) @kaa.synchronized() def foo(self): import time time.sleep(0.4) return kaa.is_mainthread() @kaa.coroutine() def test(self): r = yield self.foo() print 'foo', kaa.is_mainthread(), r @kaa.synchronized() def has_to_wait(self): print 'go' if 1: kaa.gobject_set_threaded() else: kaa.main.select_notifier('gtk') t = Test() kaa.OneShotTimer(t.test).start(0.1) kaa.OneShotTimer(t.has_to_wait).start(0.2) kaa.main.run() print 'done'
def __init__(self, player): self.name = 'livepause' self.event_context = 'tv' self.fc = FreevoChannels() self.backend = backend.get_backend() self.backend.set_mode(player.mode) self.last_channel = None self.stop_time = 0 self.data_started_timer = kaa.OneShotTimer(self.__buffering_data_timedout) self.disable_buffering_timer = kaa.OneShotTimer(self.__disable_buffering_timeout) self.state = State.IDLE self.player = player self.changing_channel = False self.subtitles = None self.subtitle_index = -1 self.audio_langs = None self.audio_lang_index = -1 self.recording = False self.state_dialog = None # Setup Event Maps self.event_maps = {} self.event_maps[State.IDLE] = { 'READER_OVERTAKEN' : self.__idle_reader_overtaken, } self.event_maps[State.TUNING] = { 'DATA_STARTED' : self.__tuning_data_started, 'DATA_TIMEDOUT': self.__tuning_data_timedout, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop } self.event_maps[State.BUFFERING] = { 'DATA_ACQUIRED': self.__buffering_data_acquired, 'DATA_TIMEDOUT': self.__buffering_data_timedout, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop } self.event_maps[State.PLAYING] = { 'PLAY' : self.__playing_play_pause, 'PAUSE' : self.__playing_play_pause, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop, 'TV_CHANNEL_UP' : self.__playing_tv_channel_up, 'TV_CHANNEL_DOWN' : self.__playing_tv_channel_down, 'TV_CHANNEL_NUMBER' : self.__playing_tv_channel_number, 'TV_START_RECORDING' : self.__playing_tv_record, 'SAVE_STARTED' : self.__playing_tv_record_start, 'SAVE_FINISHED' : self.__playing_tv_record_stop, 'BUTTON' : self.__playing_button_pressed, 'TOGGLE_OSD' : self.__playing_display_info, 'SEEK' : self.__playing_seek, 'SECONDS_LEFT' : self.__playing_seconds_left, 'READER_OVERTAKEN' : self.__playing_reader_overtaken, 'DATA_ACQUIRED' : None, 'DATA_TIMEDOUT' : None, 'VIDEO_NEXT_FILLMODE' : None, 'VIDEO_NEXT_AUDIOMODE': None, 'VIDEO_NEXT_AUDIOLANG': None, #self.__playing_toggle_audo_lang, 'VIDEO_NEXT_SUBTITLE' : self.__playing_toggle_subtitles, } self.current_event_map = self.event_maps[self.state]
# call rpc in thread x = thread2(c, 19) yield x # print 19 print x.result # 20 # Test InProgressCallable destruction cleans up signal connection. ip = kaa.inprogress(sig['one']) assert (len(sig['one']) == 1) del ip gc.collect() assert (len(sig['one']) == 0) print 'InProgressCallable cleanup ok' # Test InProgressAny via Signals.any() kaa.OneShotTimer(sig['three'].emit, 'worked').start(0.5) print 'Testing InProgressAny, should return in 0.5s' n, args = yield sig.subset('one', 'three').any() print 'InProgressAny returned:', n, args # Force InProgressCallables implicitly created by any() to be deleted. gc.collect() # Verify that they _are_ deleted and detached from the signal. print sig['one']._callbacks assert (len(sig['one']) == 0) assert (n == 1) # Test InProgressAll via Signals.all() kaa.OneShotTimer(sig['one'].emit, 'result for sig one').start(0.5) kaa.OneShotTimer(sig['two'].emit, 'result for sig two').start(0.2) print 'Testing InProgressAll, should return in 0.5s' ip = yield sig.subset('one', 'two').all()
def async (callback, *args, **kwargs): kaa.OneShotTimer(callback, *args, **kwargs).start(0.1)