def __init__(self):
plugin.DaemonPlugin.__init__(self)
self.plugin_name = 'WIIMOTE'
self.bdaddr = config.WII_ADDRESS
self.acc_activate = config.WII_ACC_ACTIVATE
self.acc_rl_repeat = config.WII_ACC_RL_REPEAT
self.acc_ud_repeat = config.WII_ACC_UD_REPEAT
self.acc_button = config.WII_ACC_BUTTON
self.acc_button_time = config.WII_ACC_BUTTON_TIME
self.ping_interval = config.WII_PING_INTERVAL
for mapping in config.WII_CMDS:
self.KEYMAP[mapping] = config.WII_CMDS.get(mapping, '')
self.rx = bluetooth.BluetoothSocket(bluetooth.L2CAP)
self.cx = bluetooth.BluetoothSocket(bluetooth.L2CAP)
self.cx.settimeout(2)
self.rx.settimeout(2)
self.rx_dispatcher = kaa.IOMonitor(self.handle_receive)
# start immediately for the first time
self.timer = kaa.Timer(self.onTimer)
self.timer.start(0.1)
self.acc_timer = kaa.Timer(self.on_acc_timer)
self.active = True
def connect(self, idlebar):
self.widget = kaa.candy.Label(None, ('100%', '50%'), 0xffffff, 'Vera')
self.widget.xalign = self.widget.ALIGN_RIGHT
self.widget.yalign = self.widget.ALIGN_CENTER
self.widget.text = time.strftime(self.format)
idlebar.add(self.widget)
kaa.Timer(self.update).start(10)
def _update_data_thread(epg,
vdr_dir=None,
channels_file=None,
epg_file=None,
host=None,
port=None,
access_by='sid',
limit_channels='conf',
exclude_channels=None):
"""
Update the guide.
"""
log.debug('_update_data_thread')
info = UpdateInfo()
info.total = 0
if not (isinstance(exclude_channels, list) or \
isinstance(exclude_channels, tuple)):
exclude_channels = []
log.info('excluding channels: %s' % exclude_channels)
info.vdr = VDR(host=host,
port=port,
videopath=vdr_dir,
channelsfile=channels_file,
epgfile=epg_file,
close_connection=0)
if info.vdr.epgfile and os.path.isfile(info.vdr.epgfile):
log.info('Using VDR EPG from %s.' % info.vdr.epgfile)
if os.path.isfile(info.vdr.channelsfile):
info.vdr.readchannels()
else:
log.warning('VDR channels file not found: %s.' %
info.vdr.channelsfile)
info.vdr.readepg()
elif info.vdr.host and info.vdr.port:
log.info('Using VDR EPG from %s:%s.' % (info.vdr.host, info.vdr.port))
info.vdr.retrievechannels()
info.vdr.retrieveepg()
else:
log.info('No source for VDR EPG.')
return False
for c in info.vdr.channels.values():
for e in c.events:
info.total += 1
info.access_by = access_by
info.limit_channels = limit_channels
info.exclude_channels = exclude_channels
info.epg = epg
info.progress_step = info.total / 100
timer = kaa.Timer(_update_process_step, info)
timer.start(0)
def add_animation(self, anim_object):
"""
Add an animation to our list
"""
self.animations.append(anim_object)
if len(self.animations) == 1:
# first animation, register ourself to the main loop:
self.timer = kaa.Timer(self.update)
self.timer.start(0.01)
def do_blend_transition(self, transition):
self.current_screen = osd.main_layer.convert()
self.screen.show(True)
self.next_screen = osd.main_layer.convert()
self.transitioning = True
self.steps = 0
self.timer = kaa.Timer(self.do_blend_step, transition)
self.do_blend_step(transition)
self.timer.start(0.01)
def __init__(self):
"""
init the lcd
"""
super(PluginInterface, self).__init__()
self.lcd = kaa.display.LCD()
self.lcd.signals['connected'].connect(self._connected)
self.running = False
self.current = []
self.timer = kaa.Timer(self.update)
def __init__(self):
""" Initialise the transcode idlebar plug-in """
logger.log(9, 'transcode.PluginInterface.__init__()')
IdleBarPlugin.__init__(self)
self.plugin_name = 'idlebar.transcode'
self.background = os.path.join(config.ICON_DIR,
'status/enc_background.png')
self.leftclamp = os.path.join(config.ICON_DIR,
'status/enc_leftclamp.png')
self.rightclamp = os.path.join(config.ICON_DIR,
'status/enc_rightclamp.png')
self.notrunning = os.path.join(config.ICON_DIR,
'status/enc_notrunning.png')
self.nojobs = os.path.join(config.ICON_DIR, 'status/enc_nojobs.png')
self.audio = os.path.join(config.ICON_DIR, 'status/enc_audio.png')
self.video = os.path.join(config.ICON_DIR, 'status/enc_video.png')
self.video1 = os.path.join(config.ICON_DIR, 'status/enc_video1.png')
self.video2 = os.path.join(config.ICON_DIR, 'status/enc_video2.png')
self.video3 = os.path.join(config.ICON_DIR, 'status/enc_video3.png')
self.multiplex = os.path.join(config.ICON_DIR,
'status/enc_multiplex.png')
self.cacheimg = {}
self.background_w, self.background_h = (0, 0)
self.leftclamp_w, self.leftclamp_h = (0, 0)
self.rightclamp_w, self.rightclamp_h = (0, 0)
self.remaining_min = re.compile('[0-9]*')
self.remaining = ''
self.progress = 0
self.progress_x = None
self.leftclamp_x = 0
self.rightclamp_x = 0
self.poll_interval = 1 # 1 sec should be same as most frequent
self.draw_interval = 5.0 # 5 secs
self.last_interval = self.poll_interval
self.lastdraw = 0
self.lastpoll = 0
self.drawtime = 0
self.server = EncodingClientActions()
self.skin = skin.get_singleton()
self.calculate = True
self.jobs = ''
self.mode = 'Not Running'
self.state = 'noserver'
self.laststate = None
self.percent = 0.0
self.running = False
self.font = self.skin.get_font(config.OSD_IDLEBAR_FONT)
self.timer = kaa.Timer(self._timerhandler)
self.timer.start(self.poll_interval)
logger.debug('transcode.PluginInterface.__init__() done.')
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, datafile):
epg.init()
self.locked = False
self.datafile = datafile
# load the recordings file
self.load_schedule()
# connect to recorder signals
device.signals['start-recording'].connect(self._recorder_start)
device.signals['stop-recording'].connect(self._recorder_stop)
device.signals['changed'].connect(self.reschedule)
# start by checking the recordings/favorites
self.check_favorites_and_reschedule()
# add schedule timer for SCHEDULE_TIMER / 3 seconds
kaa.Timer(self.check_favorites_and_reschedule).start(SCHEDULE_TIMER / 3)
def update_wait(self):
"""
This is used while starting freevo
"""
if osd._singleton == None:
return
if self.osd == None:
self.osd = osd.get_singleton()
if self.timer:
self.timer.stop()
self.update = self.update_enabled
self.timer = kaa.Timer(self.update)
self.timer.start(0.01)
def do_slide_transition(self, transition):
if transition == TRANSITION_PAGE:
self.do_blend_transition(transition)
return
self.current_screen = osd.main_layer.convert()
self.screen.show(True)
self.next_screen = osd.main_layer.convert()
self.transitioning = True
self.steps = 0
self.timer = kaa.Timer(self.do_slide_step, transition)
self.do_slide_step(transition)
self.timer.start(0.01)
def __init__(self, use_pylirc=1, use_netremote=1, is_helper=1):
_debug_('EventHandler.__init__(use_pylirc=%r, use_netremote=%r, is_helper=%r)' % \
(use_pylirc, use_netremote, is_helper), 1)
_debug_('config.HELPER=%r' % (config.HELPER,))
self.inputs = []
if not config.HELPER:
if use_pylirc:
try:
self.inputs.append(Lirc())
except:
pass
if config.USE_SDL_KEYBOARD:
try:
self.inputs.append(Keyboard())
except:
pass
if config.EVENT_DEVS:
try:
self.inputs.append(Evdev())
except:
pass
if use_netremote and config.ENABLE_NETWORK_REMOTE and config.REMOTE_CONTROL_PORT:
self.inputs.append(Network())
if use_netremote and config.ENABLE_TCP_NETWORK_REMOTE and \
config.REMOTE_CONTROL_TCP_HOST and config.REMOTE_CONTROL_TCP_PORT:
self.inputs.append(TcpNetwork())
self.app = None
self.context = 'menu'
self.callbacks = []
self.shutdown_callbacks = []
self.poll_objects = []
# lock all critical parts
#self.lock = thread.allocate_lock()
self.lock = threading.RLock()
# last time we stopped sleeping
self.sleep_timer = 0
kaa.Timer(self.poll).start(0.01)
_debug_('EventHandler.self.inputs=%r' % (self.inputs,), 1)
def get_default_cache():
"""Get the default cache to use for Freevo"""
global __default_cache
if __default_cache is None:
import config
import version
import kaa
__default_cache = WebCache(os.path.join(config.FREEVO_CACHEDIR, 'web'),
'Freevo/' + version.__version__)
# Remove expired items from the cache.
__default_cache.clean()
# Set a timer for every 30 minutes to clean the cache.
t = kaa.Timer(__default_cache.clean)
t.start(1800)
return __default_cache
def plugin_activate(self, level):
if not os.environ.get('DISPLAY') or not kaa.utils.which('xset'):
return
# get xset process to call
self.xset = kaa.Process(kaa.utils.which('xset')).start
self.counter = 0
self._mode = OFF
# Timer to poll and increase counter. It willbe started when the
# menu is shown.
self.timer = kaa.Timer(self.poll)
# register to all events
kaa.EventHandler(self.eventhandler).register()
# turn on dpms on shutdown
kaa.main.signals['shutdown'].connect(self.xset, '+dpms')
# register to application changes
freevo.signals['application-change'].connect(self.application_changed)
# turn off dpms
self.xset('-dpms s off')
def __init__(self):
plugin.DaemonPlugin.__init__(self)
self.plugin_name = 'freevused'
self.event_listener = True
self.shutdown_plugin = False
self.connected = False
self.server_sock = None
self.tx = None
self.address = 0
self.port = 0
self.data = ''
self.menuw = None
self.timer = None
self.conn_timer = None
self.osd_message_status = None
self.menu_isfresh = False
self.playing = False
self.menu_client_waiting = False
self.audioplayer = None
if hasattr(config, 'FVUSED_BIND_TIMEOUT'):
self.bind_timeout = config.FVUSED_BIND_TIMEOUT
else:
self.bind_timeout = 5
if hasattr(config, 'FVUSED_OSD_MESSAGE'):
self.osd_message = config.FVUSED_OSD_MESSAGE
else:
self.osd_message = False
if hasattr(config, 'FVUSED_CMDS'):
self.cmds = config.FVUSED_CMDS
else:
self.cmds = {
'PREV': 'UP', # 1st row left
'STRT': 'SELECT', # 1nd row center
'NEXT': 'DOWN', # 1st row right
'RWND': 'LEFT', # 2nd row left
'PAUS': 'PAUSE', # 2nd row center
'FFWD': 'RIGHT', # 2nd row right
'VOL-': 'MIXER_VOLDOWN', # 3rd row left
'STOP': 'EXIT', # 3rd row center
'VOL+': 'MIXER_VOLUP', # 3rd row right
'VOLM': 'MIXER_MUTE', # 4th row left
'SLCT': 'ENTER', # 4th row center
'MAIN': 'STOP', # 4th row right
'DISP': 'DISPLAY', # More actions
'EJEC': 'EJECT',
'DEAU': 'DISPLAY',
'CHA+': 'CH+',
'CHA-': 'CH-',
'RECO': 'REC',
'GUID': 'GUIDE',
'NUM0': '0', # Numeric keyboard
'NUM1': '1',
'NUM2': '2',
'NUM3': '3',
'NUM4': '4',
'NUM5': '5',
'NUM6': '6',
'NUM7': '7',
'NUM8': '8',
'NUM9': '9',
'STAT': 'FVUSED_ITEM_INFO'
}
# self.poll_menu_only = False
self.timer = kaa.Timer(self.timer_handler)
self.timer.start(config.POLL_TIME)
self.rc = rc.get_singleton()
self.FVUSED_ITEM_INFO = em.Event('FVUSED_ITEM_INFO')
self.connection_thread()
if method == 0:
# select the thread loop and provide callbacks for a hander and how to
# stop the real mainloop
loop = kaa.main.select_notifier('thread', handler = reactor.callFromThread, \
shutdown = reactor.stop)
# stop the thread when twisted is done. Without this code the app will wait
# until the nf thread will be done which will never happen.
reactor.addSystemEventTrigger('after', 'shutdown', loop.stop)
if method == 1:
# there is special code in kaa that does the same as method 0
kaa.main.select_notifier('twisted')
if method == 2:
# or use the real twisted mainloop
kaa.main.select_notifier('twisted_experimental')
reactor.callLater(0.5, twisted_callback1)
reactor.callLater(1.5, twisted_callback2)
kaa.Timer(kaa_callback).start(1)
kaa.main.signals['shutdown'].connect(shutdown_callback)
if method == 2:
# the twisted_experimental needs kaa.main.run()
kaa.main.run()
else:
reactor.run()
print 'done'
kaa.main.step()
test(result, [42])
result = []
kaa.WeakOneShotTimer(Cls().meth, 42).start(0)
kaa.main.step()
test(result, [])
result = []
cb = Cls().meth
kaa.WeakOneShotTimer(cb, 42).start(0)
kaa.main.step()
test(result, [42])
result = []
timer = kaa.Timer(Cls().meth, 42)
timer.start(0)
for i in range(5):
kaa.main.step()
timer.stop()
test(result, [42, 42, 42, 42, 42])
result = []
# Tests proper destruction of a weak timer. We hold a weak ref to Cls().meth
# and since there are no other refs, the weak timer never gets activated.
timer = kaa.WeakTimer(Cls().meth, 42)
timer.start(0)
# Notifier technically has nothing to do, so it may sleep for 30 seconds.
print '(This could take 30 seconds or so.)'
for i in range(2):
kaa.main.step()
print 'Warning: Freevo cache helper/information updated.'
print 'Please rerun \'freevo cache\' to speed up Freevo'
print
del_cache()
elif kaa.metadata.version.VERSION > mmchanged:
print
print 'Warning: kaa metadata as changed.'
print 'Please rerun \'freevo cache\' to get the latest updates'
print
del_cache()
elif (int(time.time()) - part_update) / (3600 * 24) > 7:
print
print 'Warning: cache is older than 7 days'
print 'Running \'freevo cache\' is recommended.'
print
except:
print
print 'Error: unable to read kaa metadata version information'
print 'Please update kaa.metadata to the latest release or if you use'
print 'Freevo svn versions, please also use kaa.metadata svn.'
print
print 'Some functions in Freevo may not work or even crash!'
print
print
import kaa
timer = kaa.Timer(check_cache_status)
timer.start(1.0)
self.cache = (wait, self.last_request_time)
return wait
scheduler = Scheduler('beacon-daemon')
check = scheduler.check
next = scheduler.next
if __name__ == '__main__':
sched1 = Scheduler(os.getpid())
sched2 = Scheduler(os.getpid())
sched3 = Scheduler(os.getpid())
def debug():
print '-----------'
print 'Polite:', sched1.next('polite')
print 'Balanced:', sched2.next('balanced')
print 'Aggressive:', sched3.next('aggressive')
@kaa.coroutine()
def add_load():
x = 0
for i in range(300000):
yield kaa.NotFinished
print "Done load generation"
add_load()
t = kaa.Timer(debug)
t.start(0.3)
kaa.main.run()
def __load_plugin__(name, type, level, args, number):
"""
load the plugin and add it to the lists
"""
import rc
global __plugin_type_list__
global __named_plugins__
global __plugin_basedir__
# fallback
module = name
object = '%s.PluginInterface' % module
special = None
# locate the plugin:
files = []
if not isinstance(name, Plugin):
module, special = __find_plugin_file__(name.replace('.', '/'))
if module:
object = module + '.PluginInterface'
elif name.find('.') > 0:
module, special = __find_plugin_file__(
name[:name.rfind('.')].replace('.', '/'))
if module:
object = module + '.%s' % name[name.rfind('.') + 1:]
else:
print 'can\'t locate plugin %r' % name
print 'start "freevo plugins -l" to get a list of plugins'
return
else:
print 'can\'t locate plugin %r' % name
print 'start "freevo plugins -l" to get a list of plugins'
return
try:
if not isinstance(name, Plugin):
logger.debug('loading %s as plugin %s', module, object)
exec('import %s' % module)
if not args:
p = eval(object)()
elif isinstance(args, list) or isinstance(args, tuple):
paramlist = 'args[0]'
for i in range(1, len(args)):
paramlist += ',args[%s]' % i
p = eval('%s(%s)' % (object, paramlist))
else:
p = eval(object)(args)
if not hasattr(p, '_type'):
if hasattr(p, 'reason'):
reason = p.reason
else:
reason = 'unknown\nThe plugin neither called __init__ nor set a '\
'reason why\nPlease contact the plugin author or the freevo list'
print 'plugin %s deactivated, reason: %s' % (name, reason)
return
else:
p = name
p._number = number
p._level = level
if type:
special = type
if special == 'main':
special = ''
elif special:
special = '_%s' % special
else:
special = ''
# special plugin type (e.g. idlebar)
if p._type:
__add_to_ptl__(p._type, p)
else:
if isinstance(p, DaemonPlugin):
__add_to_ptl__('daemon', p)
for type in ('poll', 'draw', 'eventhandler', 'shutdown'):
if hasattr(p, type):
__add_to_ptl__('daemon_%s' % type, p)
if hasattr(p, 'poll'):
if p.poll_menu_only:
# replace poll with the poll wrapper to handle
# poll_menu_only
p.timer = kaa.Timer(p.poll_wrapper)
else:
p.timer = kaa.Timer(p.poll)
p.timer.start(p.poll_interval)
if isinstance(p, MainMenuPlugin):
__add_to_ptl__('mainmenu%s' % special, p)
if hasattr(p, 'eventhandler'):
__add_to_ptl__('daemon_eventhandler', p)
if isinstance(p, ItemPlugin):
__add_to_ptl__('item%s' % special, p)
if isinstance(p, MimetypePlugin):
__add_to_ptl__('mimetype', p)
if p.plugin_name:
__named_plugins__[p.plugin_name] = p
except:
print 'failed to load plugin %s' % name
print 'start \'freevo plugins -l\' to get a list of plugins'
traceback.print_exc()
</candyxml>
'''
@kaa.coroutine()
def main():
stage = kaa.candy.Stage((400, 300), 'candy')
attr, candy = stage.candyxml(xml)
container = candy.group.g1()
stage.add(container)
yield kaa.NotFinished
yield kaa.NotFinished
container.x += 100
yield kaa.NotFinished
#container.parent = None
yield kaa.NotFinished
def garbage_collect():
gc.collect()
for g in gc.garbage:
print 'Unable to free %s' % g
# Set up garbage collector to be called every 5 seconds
kaa.Timer(garbage_collect).start(1)
main()
kaa.main.run()
print 'shutdown'
