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)
