def test_handle_keycode_macro(self):
history = []
code_a = 100
code_b = 101
system_mapping.clear()
system_mapping._set('a', code_a)
system_mapping._set('b', code_b)
macro_mapping = {
((EV_KEY, 1, 1), ): parse('k(a)', self.mapping),
((EV_KEY, 2, 1), ): parse('r(5, k(b))', self.mapping)
}
macro_mapping[((EV_KEY, 1,
1), )].set_handler(lambda *args: history.append(args))
macro_mapping[((EV_KEY, 2,
1), )].set_handler(lambda *args: history.append(args))
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None)
loop = asyncio.get_event_loop()
sleeptime = config.get('macros.keystroke_sleep_ms', 10) * 12
# let the mainloop run for some time so that the macro does its stuff
loop.run_until_complete(asyncio.sleep(sleeptime / 1000 + 0.1))
# 6 keycodes written, with down and up events
self.assertEqual(len(history), 12)
self.assertIn((code_a, 1), history)
self.assertIn((code_a, 0), history)
self.assertIn((code_b, 1), history)
self.assertIn((code_b, 0), history)
def test_4(self):
macro = parse(' r(2,\nk(\nr ).k(minus\n )).k(m) ', self.mapping)
macro.set_handler(self.handler)
r = system_mapping.get('r')
minus = system_mapping.get('minus')
m = system_mapping.get('m')
self.assertSetEqual(macro.get_capabilities(), {r, minus, m})
self.loop.run_until_complete(macro.run())
self.assertListEqual(self.result, [
(r, 1),
(r, 0),
(minus, 1),
(minus, 0),
(r, 1),
(r, 0),
(minus, 1),
(minus, 0),
(m, 1),
(m, 0),
])
self.assertEqual(len(macro.child_macros), 1)
self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_modify_capabilities(self):
class FakeDevice:
def capabilities(self, absinfo=True):
assert absinfo is False
return {
evdev.ecodes.EV_SYN: [1, 2, 3],
evdev.ecodes.EV_FF: [1, 2, 3],
evdev.ecodes.EV_ABS: [1, 2, 3]
}
mapping = Mapping()
mapping.change(Key(EV_KEY, 80, 1), 'a')
mapping.change(Key(EV_KEY, 81, 1), DISABLE_NAME)
macro_code = 'r(2, m(sHiFt_l, r(2, k(1).k(2))))'
macro = parse(macro_code, mapping)
mapping.change(Key(EV_KEY, 60, 111), macro_code)
# going to be ignored, because EV_REL cannot be mapped, that's
# mouse movements.
mapping.change(Key(EV_REL, 1234, 3), 'b')
a = system_mapping.get('a')
shift_l = system_mapping.get('ShIfT_L')
one = system_mapping.get(1)
two = system_mapping.get('2')
btn_left = system_mapping.get('BtN_lEfT')
self.injector = KeycodeInjector('foo', mapping)
fake_device = FakeDevice()
capabilities_1 = self.injector._modify_capabilities({60: macro},
fake_device,
abs_to_rel=False)
self.assertIn(EV_KEY, capabilities_1)
keys = capabilities_1[EV_KEY]
self.assertIn(a, keys)
self.assertIn(one, keys)
self.assertIn(two, keys)
self.assertIn(shift_l, keys)
self.assertNotIn(DISABLE_CODE, keys)
# abs_to_rel is false, so mouse capabilities are not needed
self.assertNotIn(btn_left, keys)
self.assertNotIn(evdev.ecodes.EV_SYN, capabilities_1)
self.assertNotIn(evdev.ecodes.EV_FF, capabilities_1)
self.assertNotIn(evdev.ecodes.EV_REL, capabilities_1)
self.assertNotIn(evdev.ecodes.EV_ABS, capabilities_1)
# abs_to_rel makes sure that BTN_LEFT is present
capabilities_2 = self.injector._modify_capabilities({60: macro},
fake_device,
abs_to_rel=True)
keys = capabilities_2[EV_KEY]
self.assertIn(a, keys)
self.assertIn(one, keys)
self.assertIn(two, keys)
self.assertIn(shift_l, keys)
self.assertIn(btn_left, keys)
def test_hold(self):
history = []
code_a = 100
code_b = 101
code_c = 102
system_mapping.clear()
system_mapping._set('a', code_a)
system_mapping._set('b', code_b)
system_mapping._set('c', code_c)
macro_mapping = {
((EV_KEY, 1, 1), ): parse('k(a).h(k(b)).k(c)', self.mapping)
}
def handler(*args):
history.append(args)
macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler)
"""start macro"""
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None)
loop = asyncio.get_event_loop()
# let the mainloop run for some time so that the macro does its stuff
sleeptime = 500
keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10)
loop.run_until_complete(asyncio.sleep(sleeptime / 1000))
self.assertTrue(active_macros[(EV_KEY, 1)].holding)
self.assertTrue(active_macros[(EV_KEY, 1)].running)
"""stop macro"""
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None)
loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000))
events = calculate_event_number(sleeptime, 1, 1)
self.assertGreater(len(history), events * 0.9)
self.assertLess(len(history), events * 1.1)
self.assertIn((code_a, 1), history)
self.assertIn((code_a, 0), history)
self.assertIn((code_b, 1), history)
self.assertIn((code_b, 0), history)
self.assertIn((code_c, 1), history)
self.assertIn((code_c, 0), history)
self.assertGreater(history.count((code_b, 1)), 1)
self.assertGreater(history.count((code_b, 0)), 1)
# it's stopped and won't write stuff anymore
count_before = len(history)
loop.run_until_complete(asyncio.sleep(0.2))
count_after = len(history)
self.assertEqual(count_before, count_after)
self.assertFalse(active_macros[(EV_KEY, 1)].holding)
self.assertFalse(active_macros[(EV_KEY, 1)].running)
def test_5(self):
start = time.time()
macro = parse('w(200).r(2,m(w,\nr(2,\tk(BtN_LeFt))).w(10).k(k))',
self.mapping)
macro.set_handler(self.handler)
self.assertEqual(len(macro.child_macros), 1)
self.assertEqual(len(macro.child_macros[0].child_macros), 1)
w = system_mapping.get('w')
left = system_mapping.get('bTn_lEfT')
k = system_mapping.get('k')
self.assertSetEqual(macro.get_capabilities(), {w, left, k})
self.loop.run_until_complete(macro.run())
num_pauses = 8 + 6 + 4
keystroke_time = num_pauses * self.mapping.get(
'macros.keystroke_sleep_ms')
wait_time = 220
total_time = (keystroke_time + wait_time) / 1000
self.assertLess(time.time() - start, total_time * 1.1)
self.assertGreater(time.time() - start, total_time * 0.9)
expected = [(w, 1)]
expected += [(left, 1), (left, 0)] * 2
expected += [(w, 0)]
expected += [(k, 1), (k, 0)]
expected *= 2
self.assertListEqual(self.result, expected)
def test_0(self):
macro = parse('k(1)', self.mapping)
macro.set_handler(self.handler)
one_code = system_mapping.get('1')
self.assertSetEqual(macro.get_capabilities(), {one_code})
self.loop.run_until_complete(macro.run())
self.assertListEqual(self.result, [(one_code, 1), (one_code, 0)])
self.assertEqual(len(macro.child_macros), 0)
def test_two_d_pad_macros(self):
# executing two macros that stop automatically at the same time
code_1 = 61
code_2 = 62
system_mapping.clear()
system_mapping._set('1', code_1)
system_mapping._set('2', code_2)
# try two concurrent macros with D-Pad events because they are
# more difficult to manage, since their only difference is their
# value, and one of them is negative.
down_1 = (EV_ABS, ABS_HAT0X, 1)
down_2 = (EV_ABS, ABS_HAT0X, -1)
repeats = 10
macro_mapping = {
(down_1, ): parse(f'r({repeats}, k(1))', self.mapping),
(down_2, ): parse(f'r({repeats}, k(2))', self.mapping)
}
history = []
def handler(*args):
history.append(args)
macro_mapping[(down_1, )].set_handler(handler)
macro_mapping[(down_2, )].set_handler(handler)
handle_keycode({}, macro_mapping, InputEvent(*down_1), None)
handle_keycode({}, macro_mapping, InputEvent(*down_2), None)
loop = asyncio.get_event_loop()
sleeptime = config.get('macros.keystroke_sleep_ms') / 1000
loop.run_until_complete(asyncio.sleep(1.1 * repeats * 2 * sleeptime))
self.assertEqual(len(history), repeats * 4)
self.assertEqual(history.count((code_1, 1)), 10)
self.assertEqual(history.count((code_1, 0)), 10)
self.assertEqual(history.count((code_2, 1)), 10)
self.assertEqual(history.count((code_2, 0)), 10)
def test_keystroke_sleep_config(self):
# global config as fallback
config.set('macros.keystroke_sleep_ms', 100)
start = time.time()
macro = parse('k(a).k(b)', self.mapping)
self.loop.run_until_complete(macro.run())
delta = time.time() - start
# is currently over 400, k(b) adds another sleep afterwards
# that doesn't do anything
self.assertGreater(delta, 0.300)
# now set the value in the mapping, which is prioritized
self.mapping.set('macros.keystroke_sleep_ms', 50)
start = time.time()
macro = parse('k(a).k(b)', self.mapping)
self.loop.run_until_complete(macro.run())
delta = time.time() - start
self.assertGreater(delta, 0.150)
self.assertLess(delta, 0.300)
def test_hold_3(self):
# test irregular input patterns
code_a = 100
code_b = 101
code_c = 102
system_mapping.clear()
system_mapping._set('a', code_a)
system_mapping._set('b', code_b)
system_mapping._set('c', code_c)
macro_mapping = {
((EV_KEY, 1, 1), ): parse('k(a).h(k(b)).k(c)', self.mapping),
}
history = []
def handler(*args):
history.append(args)
macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.sleep(0.1))
for _ in range(5):
self.assertTrue(active_macros[(EV_KEY, 1)].holding)
self.assertTrue(active_macros[(EV_KEY, 1)].running)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None)
loop.run_until_complete(asyncio.sleep(0.05))
# duplicate key down events don't do anything
self.assertEqual(history.count((code_a, 1)), 1)
self.assertEqual(history.count((code_a, 0)), 1)
self.assertEqual(history.count((code_c, 1)), 0)
self.assertEqual(history.count((code_c, 0)), 0)
# stop
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None)
loop.run_until_complete(asyncio.sleep(0.1))
self.assertEqual(history.count((code_a, 1)), 1)
self.assertEqual(history.count((code_a, 0)), 1)
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
self.assertFalse(active_macros[(EV_KEY, 1)].holding)
self.assertFalse(active_macros[(EV_KEY, 1)].running)
# it's stopped and won't write stuff anymore
count_before = len(history)
loop.run_until_complete(asyncio.sleep(0.1))
count_after = len(history)
self.assertEqual(count_before, count_after)
def check_macro_syntax(self):
"""Check if the programmed macros are allright."""
for key, output in custom_mapping:
if not is_this_a_macro(output):
continue
error = parse(output, custom_mapping, return_errors=True)
if error is None:
continue
position = to_string(key)
msg = f'Syntax error at {position}, hover for info'
self.show_status(CTX_ERROR, msg, error)
def test_1(self):
macro = parse('k(1).k(a).k(3)', self.mapping)
macro.set_handler(self.handler)
self.assertSetEqual(
macro.get_capabilities(), {
system_mapping.get('1'),
system_mapping.get('a'),
system_mapping.get('3')
})
self.loop.run_until_complete(macro.run())
self.assertListEqual(self.result, [
(system_mapping.get('1'), 1),
(system_mapping.get('1'), 0),
(system_mapping.get('a'), 1),
(system_mapping.get('a'), 0),
(system_mapping.get('3'), 1),
(system_mapping.get('3'), 0),
])
self.assertEqual(len(macro.child_macros), 0)
def test_2(self):
start = time.time()
repeats = 20
macro = parse(f'r({repeats}, k(k)).r(1, k(k))', self.mapping)
macro.set_handler(self.handler)
k_code = system_mapping.get('k')
self.assertSetEqual(macro.get_capabilities(), {k_code})
self.loop.run_until_complete(macro.run())
keystroke_sleep = self.mapping.get('macros.keystroke_sleep_ms')
sleep_time = 2 * repeats * keystroke_sleep / 1000
self.assertGreater(time.time() - start, sleep_time * 0.9)
self.assertLess(time.time() - start, sleep_time * 1.1)
self.assertListEqual(self.result, [(k_code, 1),
(k_code, 0)] * (repeats + 1))
self.assertEqual(len(macro.child_macros), 2)
self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_hold(self):
macro = parse('k(1).h(k(a)).k(3)', self.mapping)
macro.set_handler(self.handler)
self.assertSetEqual(
macro.get_capabilities(), {
system_mapping.get('1'),
system_mapping.get('a'),
system_mapping.get('3')
})
macro.press_key()
asyncio.ensure_future(macro.run())
self.loop.run_until_complete(asyncio.sleep(0.2))
macro.release_key()
self.loop.run_until_complete(asyncio.sleep(0.05))
self.assertEqual(self.result[0], (system_mapping.get('1'), 1))
self.assertEqual(self.result[-1], (system_mapping.get('3'), 0))
code_a = system_mapping.get('a')
self.assertGreater(self.result.count((code_a, 1)), 2)
self.assertEqual(len(macro.child_macros), 1)
def test_3(self):
start = time.time()
macro = parse('r(3, k(m).w(100))', self.mapping)
macro.set_handler(self.handler)
m_code = system_mapping.get('m')
self.assertSetEqual(macro.get_capabilities(), {m_code})
self.loop.run_until_complete(macro.run())
keystroke_time = 6 * self.mapping.get('macros.keystroke_sleep_ms')
total_time = keystroke_time + 300
total_time /= 1000
self.assertGreater(time.time() - start, total_time * 0.9)
self.assertLess(time.time() - start, total_time * 1.1)
self.assertListEqual(self.result, [
(m_code, 1),
(m_code, 0),
(m_code, 1),
(m_code, 0),
(m_code, 1),
(m_code, 0),
])
self.assertEqual(len(macro.child_macros), 1)
self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_hold_two(self):
# holding two macros at the same time,
# the first one is triggered by a combination
history = []
code_1 = 100
code_2 = 101
code_3 = 102
code_a = 103
code_b = 104
code_c = 105
system_mapping.clear()
system_mapping._set('1', code_1)
system_mapping._set('2', code_2)
system_mapping._set('3', code_3)
system_mapping._set('a', code_a)
system_mapping._set('b', code_b)
system_mapping._set('c', code_c)
key_0 = (EV_KEY, 10)
key_1 = (EV_KEY, 11)
key_2 = (EV_ABS, ABS_HAT0X)
down_0 = (*key_0, 1)
down_1 = (*key_1, 1)
down_2 = (*key_2, -1)
up_0 = (*key_0, 0)
up_1 = (*key_1, 0)
up_2 = (*key_2, 0)
macro_mapping = {
(down_0, down_1): parse('k(1).h(k(2)).k(3)', self.mapping),
(down_2, ): parse('k(a).h(k(b)).k(c)', self.mapping)
}
def handler(*args):
history.append(args)
macro_mapping[(down_0, down_1)].set_handler(handler)
macro_mapping[(down_2, )].set_handler(handler)
loop = asyncio.get_event_loop()
macros_uinput = UInput()
keys_uinput = UInput()
# key up won't do anything
handle_keycode({}, macro_mapping, InputEvent(*up_0), macros_uinput)
handle_keycode({}, macro_mapping, InputEvent(*up_1), macros_uinput)
handle_keycode({}, macro_mapping, InputEvent(*up_2), macros_uinput)
loop.run_until_complete(asyncio.sleep(0.1))
self.assertEqual(len(active_macros), 0)
"""start macros"""
handle_keycode({}, macro_mapping, InputEvent(*down_0), keys_uinput)
self.assertEqual(keys_uinput.write_count, 1)
handle_keycode({}, macro_mapping, InputEvent(*down_1), keys_uinput)
handle_keycode({}, macro_mapping, InputEvent(*down_2), keys_uinput)
self.assertEqual(keys_uinput.write_count, 1)
# let the mainloop run for some time so that the macro does its stuff
sleeptime = 500
keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10)
loop.run_until_complete(asyncio.sleep(sleeptime / 1000))
self.assertEqual(len(active_macros), 2)
self.assertTrue(active_macros[key_1].holding)
self.assertTrue(active_macros[key_1].running)
self.assertTrue(active_macros[key_2].holding)
self.assertTrue(active_macros[key_2].running)
"""stop macros"""
# releasing the last key of a combination releases the whole macro
handle_keycode({}, macro_mapping, InputEvent(*up_1), None)
handle_keycode({}, macro_mapping, InputEvent(*up_2), None)
loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000))
self.assertFalse(active_macros[key_1].holding)
self.assertFalse(active_macros[key_1].running)
self.assertFalse(active_macros[key_2].holding)
self.assertFalse(active_macros[key_2].running)
events = calculate_event_number(sleeptime, 1, 1) * 2
self.assertGreater(len(history), events * 0.9)
self.assertLess(len(history), events * 1.1)
self.assertIn((code_a, 1), history)
self.assertIn((code_a, 0), history)
self.assertIn((code_b, 1), history)
self.assertIn((code_b, 0), history)
self.assertIn((code_c, 1), history)
self.assertIn((code_c, 0), history)
self.assertIn((code_1, 1), history)
self.assertIn((code_1, 0), history)
self.assertIn((code_2, 1), history)
self.assertIn((code_2, 0), history)
self.assertIn((code_3, 1), history)
self.assertIn((code_3, 0), history)
self.assertGreater(history.count((code_b, 1)), 1)
self.assertGreater(history.count((code_b, 0)), 1)
self.assertGreater(history.count((code_2, 1)), 1)
self.assertGreater(history.count((code_2, 0)), 1)
# it's stopped and won't write stuff anymore
count_before = len(history)
loop.run_until_complete(asyncio.sleep(0.2))
count_after = len(history)
self.assertEqual(count_before, count_after)
def test_hold_2(self):
# test irregular input patterns
code_a = 100
code_b = 101
code_c = 102
code_d = 103
system_mapping.clear()
system_mapping._set('a', code_a)
system_mapping._set('b', code_b)
system_mapping._set('c', code_c)
system_mapping._set('d', code_d)
macro_mapping = {
((EV_KEY, 1, 1), ):
parse('h(k(b))', self.mapping),
((EV_KEY, 2, 1), ):
parse('k(c).r(1, r(1, r(1, h(k(a))))).k(d)', self.mapping),
((EV_KEY, 3, 1), ):
parse('h(k(b))', self.mapping)
}
history = []
def handler(*args):
history.append(args)
macro_mapping[((EV_KEY, 1, 1), )].set_handler(handler)
macro_mapping[((EV_KEY, 2, 1), )].set_handler(handler)
macro_mapping[((EV_KEY, 3, 1), )].set_handler(handler)
"""start macro 2"""
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.sleep(0.1))
# starting code_c written
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
# spam garbage events
for _ in range(5):
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 1), None)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 1), None)
loop.run_until_complete(asyncio.sleep(0.05))
self.assertTrue(active_macros[(EV_KEY, 1)].holding)
self.assertTrue(active_macros[(EV_KEY, 1)].running)
self.assertTrue(active_macros[(EV_KEY, 2)].holding)
self.assertTrue(active_macros[(EV_KEY, 2)].running)
self.assertTrue(active_macros[(EV_KEY, 3)].holding)
self.assertTrue(active_macros[(EV_KEY, 3)].running)
# there should only be one code_c in the events, because no key
# up event was ever done so the hold just continued
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
# without an key up event on 2, it won't write code_d
self.assertNotIn((code_d, 1), history)
self.assertNotIn((code_d, 0), history)
# stop macro 2
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 0), None)
loop.run_until_complete(asyncio.sleep(0.1))
# it stopped and didn't restart, so the count stays at 1
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
# and the trailing d was written
self.assertEqual(history.count((code_d, 1)), 1)
self.assertEqual(history.count((code_d, 0)), 1)
# it's stopped and won't write stuff anymore
count_before = history.count((code_a, 1))
self.assertGreater(count_before, 1)
loop.run_until_complete(asyncio.sleep(0.1))
count_after = history.count((code_a, 1))
self.assertEqual(count_before, count_after)
"""restart macro 2"""
history = []
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 1), None)
loop.run_until_complete(asyncio.sleep(0.1))
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
# spam garbage events again, this time key-up events on all other
# macros
for _ in range(5):
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 0), None)
loop.run_until_complete(asyncio.sleep(0.05))
self.assertFalse(active_macros[(EV_KEY, 1)].holding)
self.assertFalse(active_macros[(EV_KEY, 1)].running)
self.assertTrue(active_macros[(EV_KEY, 2)].holding)
self.assertTrue(active_macros[(EV_KEY, 2)].running)
self.assertFalse(active_macros[(EV_KEY, 3)].holding)
self.assertFalse(active_macros[(EV_KEY, 3)].running)
# stop macro 2
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 2, 0), None)
loop.run_until_complete(asyncio.sleep(0.1))
# was started only once
self.assertEqual(history.count((code_c, 1)), 1)
self.assertEqual(history.count((code_c, 0)), 1)
# and the trailing d was also written only once
self.assertEqual(history.count((code_d, 1)), 1)
self.assertEqual(history.count((code_d, 0)), 1)
# stop all macros
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 1, 0), None)
handle_keycode({}, macro_mapping, InputEvent(EV_KEY, 3, 0), None)
loop.run_until_complete(asyncio.sleep(0.1))
# it's stopped and won't write stuff anymore
count_before = len(history)
loop.run_until_complete(asyncio.sleep(0.1))
count_after = len(history)
self.assertEqual(count_before, count_after)
self.assertFalse(active_macros[(EV_KEY, 1)].holding)
self.assertFalse(active_macros[(EV_KEY, 1)].running)
self.assertFalse(active_macros[(EV_KEY, 2)].holding)
self.assertFalse(active_macros[(EV_KEY, 2)].running)
self.assertFalse(active_macros[(EV_KEY, 3)].holding)
self.assertFalse(active_macros[(EV_KEY, 3)].running)
def _start_injecting(self):
"""The injection worker that keeps injecting until terminated.
Stuff is non-blocking by using asyncio in order to do multiple things
somewhat concurrently.
Use this function as starting point in a process. It creates
the loops needed to read and map events and keeps running them.
"""
# create a new event loop, because somehow running an infinite loop
# that sleeps on iterations (ev_abs_mapper) in one process causes
# another injection process to screw up reading from the grabbed
# device.
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
numlock_state = is_numlock_on()
loop = asyncio.get_event_loop()
coroutines = []
logger.info('Starting injecting the mapping for "%s"', self.device)
paths = get_devices()[self.device]['paths']
# Watch over each one of the potentially multiple devices per hardware
for path in paths:
source, abs_to_rel = self._prepare_device(path)
if source is None:
continue
# each device needs own macro instances to add a custom handler
logger.debug('Parsing macros for %s', path)
macros = {}
for key, output in self.mapping:
if is_this_a_macro(output):
macro = parse(output, self.mapping)
if macro is None:
continue
for permutation in key.get_permutations():
macros[permutation.keys] = macro
if len(macros) == 0:
logger.debug('No macros configured')
# certain capabilities can have side effects apparently. with an
# EV_ABS capability, EV_REL won't move the mouse pointer anymore.
# so don't merge all InputDevices into one UInput device.
uinput = evdev.UInput(name=f'{DEV_NAME} {self.device}',
phys=DEV_NAME,
events=self._modify_capabilities(
macros, source, abs_to_rel))
logger.spam('Injected capabilities for "%s": %s', path,
uinput.capabilities(verbose=True))
def handler(*args, uinput=uinput):
# this ensures that the right uinput is used for macro_write,
# because this is within a loop
self._macro_write(*args, uinput)
for macro in macros.values():
macro.set_handler(handler)
# actual reading of events
coroutines.append(
self._event_consumer(macros, source, uinput, abs_to_rel))
# mouse movement injection based on the results of the
# event consumer
if abs_to_rel:
self.abs_state[0] = 0
self.abs_state[1] = 0
coroutines.append(
ev_abs_mapper(self.abs_state, source, uinput,
self.mapping))
if len(coroutines) == 0:
logger.error('Did not grab any device')
return
coroutines.append(self._msg_listener(loop))
# set the numlock state to what it was before injecting, because
# grabbing devices screws this up
set_numlock(numlock_state)
try:
loop.run_until_complete(asyncio.gather(*coroutines))
except RuntimeError:
# stopped event loop most likely
pass
except OSError as error:
logger.error(str(error))
if len(coroutines) > 0:
logger.debug('asyncio coroutines ended')
def test_return_errors(self):
error = parse('k(1).h(k(a)).k(3)', self.mapping, return_errors=True)
self.assertIsNone(error)
error = parse('k(1))', self.mapping, return_errors=True)
self.assertIn('bracket', error)
error = parse('k((1)', self.mapping, return_errors=True)
self.assertIn('bracket', error)
error = parse('k((1).k)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('r(a, k(1))', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('k()', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('k(1)', self.mapping, return_errors=True)
self.assertIsNone(error)
error = parse('k(1, 1)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('h(1, 1)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('h(h(h(1, 1)))', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('r(1)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('r(1, 1)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('r(k(1), 1)', self.mapping, return_errors=True)
self.assertIsNotNone(error)
error = parse('r(1, k(1))', self.mapping, return_errors=True)
self.assertIsNone(error)
def test_fails(self):
self.assertIsNone(parse('r(1, a)', self.mapping))
self.assertIsNone(parse('r(a, k(b))', self.mapping))
self.assertIsNone(parse('m(a, b)', self.mapping))
def test_6(self):
# does nothing without .run
macro = parse('k(a).r(3, k(b))', self.mapping)
macro.set_handler(self.handler)
self.assertIsInstance(macro, _Macro)
self.assertListEqual(self.result, [])
