''' Input recorder ============== .. versionadded:: 1.1.0 .. warning:: This part of Kivy is still experimental and this API is subject to change in a future version. This is a class that can record and replay some input events. This can be used for test cases, screen savers etc. Once activated, the recorder will listen for any input event and save its properties in a file with the delta time. Later, you can play the input file: it will generate fake touch events with the saved properties and dispatch it to the event loop. By default, only the position is saved ('pos' profile and 'sx', 'sy', attributes). Change it only if you understand how input handling works. Recording events ---------------- The best way is to use the "recorder" module. Check the :doc:`api-kivy.modules` documentation to see how to activate a module. Once activated, you can press F8 to start the recording. By default, events will be written to `/recorder.kvi`. When you want to stop recording, press F8 again. You can replay the file by pressing F7. Check the :doc:`api-kivy.modules.recorder` module for more information. Manual play ----------- You can manually open a recorder file, and play it by doing:: from kivy.input.recorder import Recorder rec = Recorder(filename='myrecorder.kvi') rec.play = True If you want to loop over that file, you can do:: from kivy.input.recorder import Recorder def recorder_loop(instance, value): if value is False: instance.play = True rec = Recorder(filename='myrecorder.kvi') rec.bind(play=recorder_loop) rec.play = True Recording more attributes ------------------------- You can extend the attributes to save on one condition: attributes values must be simple values, not instances of complex classes. Let's say you want to save the angle and pressure of the touch, if available:: from kivy.input.recorder import Recorder rec = Recorder(filename='myrecorder.kvi', record_attrs=['is_touch', 'sx', 'sy', 'angle', 'pressure'], record_profile_mask=['pos', 'angle', 'pressure']) rec.record = True Or with modules variables:: $ python main.py -m recorder,attrs=is_touch:sx:sy:angle:pressure, \ profile_mask=pos:angle:pressure Known limitations ----------------- - Unable to save attributes with instances of complex classes. - Values that represent time will not be adjusted. - Can replay only complete records. If a begin/update/end event is missing, this could lead to ghost touches. - Stopping the replay before the end can lead to ghost touches. ''' __all__ = ('Recorder', ) from os.path import exists from time import time from kivy.event import EventDispatcher from kivy.properties import ObjectProperty, BooleanProperty, StringProperty, \ NumericProperty, ListProperty from kivy.input.motionevent import MotionEvent from kivy.base import EventLoop from kivy.logger import Logger from ast import literal_eval from functools import partial class RecorderMotionEvent(MotionEvent): def depack(self, args): for key, value in list(args.items()): setattr(self, key, value) super(RecorderMotionEvent, self).depack(args) class Recorder(EventDispatcher): '''Recorder class. Please check module documentation for more information. :Events: `on_stop`: Fired when the playing stops. .. versionchanged:: 1.10.0 Event `on_stop` added. ''' window = ObjectProperty(None) '''Window instance to attach the recorder. If None, it will use the default instance. :attr:`window` is a :class:`~kivy.properties.ObjectProperty` and defaults to None. ''' counter = NumericProperty(0) '''Number of events recorded in the last session. :attr:`counter` is a :class:`~kivy.properties.NumericProperty` and defaults to 0, read-only. ''' play = BooleanProperty(False) '''Boolean to start/stop the replay of the current file (if it exists). :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults to False. ''' record = BooleanProperty(False) '''Boolean to start/stop the recording of input events. :attr:`record` is a :class:`~kivy.properties.BooleanProperty` and defaults to False. ''' filename = StringProperty('recorder.kvi') '''Filename to save the output of the recorder. :attr:`filename` is a :class:`~kivy.properties.StringProperty` and defaults to 'recorder.kvi'. ''' record_attrs = ListProperty(['is_touch', 'sx', 'sy']) '''Attributes to record from the motion event. :attr:`record_attrs` is a :class:`~kivy.properties.ListProperty` and defaults to ['is_touch', 'sx', 'sy']. ''' record_profile_mask = ListProperty(['pos']) '''Profile to save in the fake motion event when replayed. :attr:`record_profile_mask` is a :class:`~kivy.properties.ListProperty` and defaults to ['pos']. ''' # internals record_fd = ObjectProperty(None) record_time = NumericProperty(0.) __events__ = ('on_stop',) def __init__(self, **kwargs): super(Recorder, self).__init__(**kwargs) if self.window is None: # manually set the current window from kivy.core.window import Window self.window = Window self.window.bind( on_motion=self.on_motion, on_key_up=partial(self.on_keyboard, 'keyup'), on_key_down=partial(self.on_keyboard, 'keydown'), on_keyboard=partial(self.on_keyboard, 'keyboard')) def on_motion(self, window, etype, motionevent): if not self.record: return args = dict((arg, getattr(motionevent, arg)) for arg in self.record_attrs if hasattr(motionevent, arg)) args['profile'] = [x for x in motionevent.profile if x in self.record_profile_mask] self.record_fd.write('%r\n' % ( (time() - self.record_time, etype, motionevent.uid, args), )) self.counter += 1 def on_keyboard(self, etype, window, key, *args, **kwargs): if not self.record: return self.record_fd.write('%r\n' % ( (time() - self.record_time, etype, 0, { 'key': key, 'scancode': kwargs.get('scancode'), 'codepoint': kwargs.get('codepoint', kwargs.get('unicode')), 'modifier': kwargs.get('modifier'), 'is_touch': False}), )) self.counter += 1 def release(self): self.window.unbind( on_motion=self.on_motion, on_key_up=self.on_keyboard, on_key_down=self.on_keyboard) def on_record(self, instance, value): if value: # generate a record filename self.counter = 0 self.record_time = time() self.record_fd = open(self.filename, 'w') self.record_fd.write('#RECORDER1.0\n') Logger.info('Recorder: Recording inputs to %r' % self.filename) else: self.record_fd.close() Logger.info('Recorder: Recorded %d events in %r' % (self.counter, self.filename)) # needed for acting as an input provider def stop(self): pass def start(self): pass def on_play(self, instance, value): if not value: Logger.info('Recorder: Stop playing %r' % self.filename) EventLoop.remove_input_provider(self) return if not exists(self.filename): Logger.error('Recorder: Unable to find %r file, play aborted.' % ( self.filename)) return with open(self.filename, 'r') as fd: data = fd.read().splitlines() if len(data) < 2: Logger.error('Recorder: Unable to play %r, file truncated.' % ( self.filename)) return if data[0] != '#RECORDER1.0': Logger.error('Recorder: Unable to play %r, invalid header.' % ( self.filename)) return # decompile data self.play_data = [literal_eval(x) for x in data[1:]] self.play_time = time() self.play_me = {} Logger.info('Recorder: Start playing %d events from %r' % (len(self.play_data), self.filename)) EventLoop.add_input_provider(self) def on_stop(self): pass def update(self, dispatch_fn): if not self.play_data: Logger.info('Recorder: Playing finished.') self.play = False self.dispatch('on_stop') dt = time() - self.play_time while self.play_data: event = self.play_data[0] assert(len(event) == 4) if event[0] > dt: return me = None etype, uid, args = event[1:] if etype == 'begin': me = RecorderMotionEvent('recorder', uid, args) self.play_me[uid] = me elif etype == 'update': me = self.play_me[uid] me.depack(args) elif etype == 'end': me = self.play_me.pop(uid) me.depack(args) elif etype == 'keydown': self.window.dispatch( 'on_key_down', args['key'], args['scancode'], args['codepoint'], args['modifier']) elif etype == 'keyup': self.window.dispatch( 'on_key_up', args['key'], args['scancode'], args['codepoint'], args['modifier']) elif etype == 'keyboard': self.window.dispatch( 'on_keyboard', args['key'], args['scancode'], args['codepoint'], args['modifier']) if me: dispatch_fn(etype, me) self.play_data.pop(0) def start(win, ctx): ctx.recorder = Recorder(window=win) def stop(win, ctx): if hasattr(ctx, 'recorder'): ctx.recorder.release()