def test_refresh_on_start(self):
if os.path.exists(get_config_path('xmodmap.json')):
os.remove(get_config_path('xmodmap.json'))
ev = (EV_KEY, 9)
keycode_to = 100
group_name = '9876 name'
# expected key of the group
group_key = group_name
group = groups.find(name=group_name)
# this test only makes sense if this device is unknown yet
self.assertIsNone(group)
custom_mapping.change(Key(*ev, 1), 'a')
system_mapping.clear()
system_mapping._set('a', keycode_to)
# make the daemon load the file instead
with open(get_config_path('xmodmap.json'), 'w') as file:
json.dump(system_mapping._mapping, file, indent=4)
system_mapping.clear()
preset = 'foo'
custom_mapping.save(get_preset_path(group_name, preset))
config.set_autoload_preset(group_key, preset)
push_events(group_key, [new_event(*ev, 1)])
self.daemon = Daemon()
# make sure the devices are populated
groups.refresh()
# the daemon is supposed to find this device by calling refresh
fixtures[self.new_fixture_path] = {
'capabilities': {
evdev.ecodes.EV_KEY: [ev[1]]
},
'phys': '9876 phys',
'info': evdev.device.DeviceInfo(4, 5, 6, 7),
'name': group_name
}
self.daemon.set_config_dir(get_config_path())
self.daemon.start_injecting(group_key, preset)
# test if the injector called groups.refresh successfully
group = groups.find(key=group_key)
self.assertEqual(group.name, group_name)
self.assertEqual(group.key, group_key)
time.sleep(0.1)
self.assertTrue(uinput_write_history_pipe[0].poll())
event = uinput_write_history_pipe[0].recv()
self.assertEqual(event.t, (EV_KEY, keycode_to, 1))
self.daemon.stop_injecting(group_key)
self.assertEqual(self.daemon.get_state(group_key), STOPPED)
def test_autoload(self):
preset = 'preset7'
group = groups.find(key='Foo Device 2')
daemon = Daemon()
self.daemon = daemon
self.daemon.set_config_dir(get_config_path())
mapping = Mapping()
mapping.change(Key(3, 2, 1), 'a')
mapping.save(group.get_preset_path(preset))
# no autoloading is configured yet
self.daemon._autoload(group.key)
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
config.set_autoload_preset(group.key, preset)
config.save_config()
self.daemon.set_config_dir(get_config_path())
len_before = len(self.daemon.autoload_history._autoload_history)
# now autoloading is configured, so it will autoload
self.daemon._autoload(group.key)
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(
daemon.autoload_history._autoload_history[group.key][1], preset)
self.assertFalse(
daemon.autoload_history.may_autoload(group.key, preset))
injector = daemon.injectors[group.key]
self.assertEqual(len_before + 1, len_after)
# calling duplicate _autoload does nothing
self.daemon._autoload(group.key)
self.assertEqual(
daemon.autoload_history._autoload_history[group.key][1], preset)
self.assertEqual(injector, daemon.injectors[group.key])
self.assertFalse(
daemon.autoload_history.may_autoload(group.key, preset))
# explicit start_injecting clears the autoload history
self.daemon.start_injecting(group.key, preset)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
# calling autoload for (yet) unknown devices does nothing
len_before = len(self.daemon.autoload_history._autoload_history)
self.daemon._autoload('unknown-key-1234')
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(len_before, len_after)
# autoloading key-mapper devices does nothing
len_before = len(self.daemon.autoload_history._autoload_history)
self.daemon.autoload_single('Bar Device')
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(len_before, len_after)
def test_autoload(self):
device = 'device 1'
preset = 'preset7'
path = '/dev/input/event11'
daemon = Daemon()
self.daemon = daemon
self.daemon.set_config_dir(get_config_path())
mapping = Mapping()
mapping.change(Key(3, 2, 1), 'a')
mapping.save(get_preset_path(device, preset))
# no autoloading is configured yet
self.daemon._autoload(device)
self.daemon._autoload(path)
self.assertNotIn(device, daemon.autoload_history._autoload_history)
self.assertTrue(daemon.autoload_history.may_autoload(device, preset))
config.set_autoload_preset(device, preset)
config.save_config()
self.daemon.set_config_dir(get_config_path())
len_before = len(self.daemon.autoload_history._autoload_history)
self.daemon._autoload(path)
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(daemon.autoload_history._autoload_history[device][1], preset)
self.assertFalse(daemon.autoload_history.may_autoload(device, preset))
injector = daemon.injectors[device]
self.assertEqual(len_before + 1, len_after)
# calling duplicate _autoload does nothing
self.daemon._autoload(path)
self.assertEqual(daemon.autoload_history._autoload_history[device][1], preset)
self.assertEqual(injector, daemon.injectors[device])
self.assertFalse(daemon.autoload_history.may_autoload(device, preset))
# explicit start_injecting clears the autoload history
self.daemon.start_injecting(device, preset)
self.assertTrue(daemon.autoload_history.may_autoload(device, preset))
# calling autoload for (yet) unknown devices does nothing
len_before = len(self.daemon.autoload_history._autoload_history)
self.daemon._autoload('/dev/input/qux')
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(len_before, len_after)
# autoloading key-mapper devices does nothing
len_before = len(self.daemon.autoload_history._autoload_history)
self.daemon.autoload_single('/dev/input/event40')
len_after = len(self.daemon.autoload_history._autoload_history)
self.assertEqual(len_before, len_after)
def populate(self):
"""Get a mapping of all available names to their keycodes."""
logger.debug('Gathering available keycodes')
self.clear()
xmodmap_dict = {}
try:
xmodmap = subprocess.check_output(
['xmodmap', '-pke'], stderr=subprocess.STDOUT).decode()
xmodmap = xmodmap
self._xmodmap = re.findall(r'(\d+) = (.+)\n', xmodmap + '\n')
xmodmap_dict = self._find_legit_mappings()
except (subprocess.CalledProcessError, FileNotFoundError):
# might be within a tty
pass
if USER != 'root':
# write this stuff into the key-mapper config directory, because
# the systemd service won't know the user sessions xmodmap
path = get_config_path(XMODMAP_FILENAME)
touch(path)
with open(path, 'w') as file:
logger.debug('Writing "%s"', path)
json.dump(xmodmap_dict, file, indent=4)
for name, code in xmodmap_dict.items():
self._set(name, code)
for name, ecode in evdev.ecodes.ecodes.items():
if name.startswith('KEY') or name.startswith('BTN'):
self._set(name, ecode)
self._set(DISABLE_NAME, DISABLE_CODE)
def on_autoload_switch(self, _, active):
"""Load the preset automatically next time the user logs in."""
device = self.selected_device
preset = self.selected_preset
config.set_autoload_preset(device, preset if active else None)
config.save_config()
# tell the service to refresh its config
self.dbus.set_config_dir(get_config_path())
def on_autoload_switch(self, _, active):
"""Load the preset automatically next time the user logs in."""
key = self.group.key
preset = self.preset_name
config.set_autoload_preset(key, preset if active else None)
config.save_config()
# tell the service to refresh its config
self.dbus.set_config_dir(get_config_path())
def on_apply_preset_clicked(self, _):
"""Apply a preset without saving changes."""
self.save_preset()
if custom_mapping.num_saved_keys == 0:
logger.error('Cannot apply empty preset file')
# also helpful for first time use
if custom_mapping.changed:
self.show_status(
CTX_ERROR, 'You need to save your changes first',
'No mappings are stored in the preset .json file yet')
else:
self.show_status(CTX_ERROR,
'You need to add keys and save first')
return
preset = self.selected_preset
device = self.selected_device
logger.info('Applying preset "%s" for "%s"', preset, device)
if not self.button_left_warn:
if custom_mapping.dangerously_mapped_btn_left():
self.show_status(
CTX_ERROR, 'This would disable your click button',
'Map a button to BTN_LEFT to avoid this.\n'
'To overwrite this warning, press apply again.')
self.button_left_warn = True
return
if not self.unreleased_warn:
unreleased = reader.get_unreleased_keys()
if unreleased is not None and unreleased != Key.btn_left():
# it's super annoying if that happens and may break the user
# input in such a way to prevent disabling the mapping
logger.error(
'Tried to apply a preset while keys were held down: %s',
unreleased)
self.show_status(
CTX_ERROR, 'Please release your pressed keys first',
'X11 will think they are held down forever otherwise.\n'
'To overwrite this warning, press apply again.')
self.unreleased_warn = True
return
self.unreleased_warn = False
self.button_left_warn = False
self.dbus.set_config_dir(get_config_path())
self.dbus.start_injecting(device, preset)
self.show_status(CTX_APPLY, 'Starting injection...')
GLib.timeout_add(100, self.show_injection_result)
def populate(self):
"""Get a mapping of all available names to their keycodes."""
logger.debug('Gathering available keycodes')
self.clear()
xmodmap_dict = {}
try:
xmodmap = subprocess.check_output(['xmodmap', '-pke']).decode()
xmodmap = xmodmap.lower()
mappings = re.findall(r'(\d+) = (.+)\n', xmodmap + '\n')
for keycode, names in mappings:
# there might be multiple, like:
# keycode 64 = Alt_L Meta_L Alt_L Meta_L
# keycode 204 = NoSymbol Alt_L NoSymbol Alt_L
# Alt_L should map to code 64. Writing code 204 only works
# if a modifier is applied at the same time. So take the first
# one.
name = names.split()[0]
xmodmap_dict[name] = int(keycode) - XKB_KEYCODE_OFFSET
for keycode, names in mappings:
# but since KP may be mapped like KP_Home KP_7 KP_Home KP_7,
# make another pass and add all of them if they don't already
# exist. don't overwrite any keycodes.
for name in names.split():
if xmodmap_dict.get(name) is None:
xmodmap_dict[name] = int(keycode) - XKB_KEYCODE_OFFSET
except (subprocess.CalledProcessError, FileNotFoundError):
# might be within a tty
pass
if USER != 'root':
# write this stuff into the key-mapper config directory, because
# the systemd service won't know the user sessions xmodmap
path = get_config_path(XMODMAP_FILENAME)
touch(path)
with open(path, 'w') as file:
logger.info('Writing "%s"', path)
json.dump(xmodmap_dict, file, indent=4)
self._mapping.update(xmodmap_dict)
for name, ecode in evdev.ecodes.ecodes.items():
if name.startswith('KEY') or name.startswith('BTN'):
self._set(name, ecode)
self._set(DISABLE_NAME, DISABLE_CODE)
def on_apply_preset_clicked(self, _):
"""Apply a preset without saving changes."""
preset = self.selected_preset
device = self.selected_device
logger.info('Applying preset "%s" for "%s"', preset, device)
if custom_mapping.changed:
self.show_status(CTX_WARNING,
f'Applied outdated preset "{preset}"',
'Click "Save" first for changes to take effect')
else:
self.show_status(CTX_APPLY, f'Applied preset "{preset}"')
path = get_preset_path(device, preset)
xmodmap = get_config_path(XMODMAP_FILENAME)
success = self.dbus.start_injecting(device, path, xmodmap)
if not success:
self.show_status(CTX_ERROR, 'Error: Could not grab devices!')
GLib.timeout_add(10, self.show_device_mapping_status)
def test_autoload_3(self):
# based on a bug
preset = 'preset7'
group = groups.find(key='Foo Device 2')
mapping = Mapping()
mapping.change(Key(3, 2, 1), 'a')
mapping.save(group.get_preset_path(preset))
config.set_autoload_preset(group.key, preset)
config.save_config()
self.daemon = Daemon()
self.daemon.set_config_dir(get_config_path())
groups.set_groups([]) # caused the bug
self.assertIsNone(groups.find(key='Foo Device 2'))
self.daemon.autoload()
# it should try to refresh the groups because all the
# group_keys are unknown at the moment
history = self.daemon.autoload_history._autoload_history
self.assertEqual(history[group.key][1], preset)
self.assertEqual(self.daemon.get_state(group.key), STARTING)
self.assertIsNotNone(groups.find(key='Foo Device 2'))
def test_autoload_2(self):
self.daemon = Daemon()
history = self.daemon.autoload_history._autoload_history
# existing device
preset = 'preset7'
group = groups.find(key='Foo Device 2')
mapping = Mapping()
mapping.change(Key(3, 2, 1), 'a')
mapping.save(group.get_preset_path(preset))
config.set_autoload_preset(group.key, preset)
# ignored, won't cause problems:
config.set_autoload_preset('non-existant-key', 'foo')
# daemon is missing the config directory yet
self.daemon.autoload()
self.assertEqual(len(history), 0)
config.save_config()
self.daemon.set_config_dir(get_config_path())
self.daemon.autoload()
self.assertEqual(len(history), 1)
self.assertEqual(history[group.key][1], preset)
def quick_cleanup(log=True):
"""Reset the applications state."""
if log:
print('quick cleanup')
for device in list(pending_events.keys()):
try:
while pending_events[device][1].poll():
pending_events[device][1].recv()
except (UnpicklingError, EOFError):
pass
# setup new pipes for the next test
pending_events[device] = None
setup_pipe(device)
try:
reader.terminate()
except (BrokenPipeError, OSError):
pass
if asyncio.get_event_loop().is_running():
for task in asyncio.all_tasks():
task.cancel()
if not macro_variables.process.is_alive():
raise AssertionError('the SharedDict manager is not running anymore')
macro_variables._stop()
join_children()
macro_variables._start()
if os.path.exists(tmp):
shutil.rmtree(tmp)
config.path = os.path.join(get_config_path(), 'config.json')
config.clear_config()
config.save_config()
system_mapping.populate()
custom_mapping.empty()
custom_mapping.clear_config()
custom_mapping.changed = False
clear_write_history()
for name in list(uinputs.keys()):
del uinputs[name]
for device in list(active_macros.keys()):
del active_macros[device]
for device in list(unreleased.keys()):
del unreleased[device]
for path in list(fixtures.keys()):
if path not in _fixture_copy:
del fixtures[path]
for path in list(_fixture_copy.keys()):
fixtures[path] = copy.deepcopy(_fixture_copy[path])
os.environ.update(environ_copy)
for device in list(os.environ.keys()):
if device not in environ_copy:
del os.environ[device]
reader.clear()
for _, pipe in pending_events.values():
assert not pipe.poll()
assert macro_variables.is_alive(1)
def setUp(self):
self.grab = evdev.InputDevice.grab
self.daemon = None
mkdir(get_config_path())
config.save_config()
def test_start_stop(self):
group = groups.find(key='Foo Device 2')
preset = 'preset8'
daemon = Daemon()
self.daemon = daemon
mapping = Mapping()
mapping.change(Key(3, 2, 1), 'a')
mapping.save(group.get_preset_path(preset))
# the daemon needs set_config_dir first before doing anything
daemon.start_injecting(group.key, preset)
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertNotIn(group.key, daemon.injectors)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
# start
config.save_config()
daemon.set_config_dir(get_config_path())
daemon.start_injecting(group.key, preset)
# explicit start, not autoload, so the history stays empty
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
# path got translated to the device name
self.assertIn(group.key, daemon.injectors)
# start again
previous_injector = daemon.injectors[group.key]
self.assertNotEqual(previous_injector.get_state(), STOPPED)
daemon.start_injecting(group.key, preset)
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
self.assertIn(group.key, daemon.injectors)
self.assertEqual(previous_injector.get_state(), STOPPED)
# a different injetor is now running
self.assertNotEqual(previous_injector, daemon.injectors[group.key])
self.assertNotEqual(daemon.injectors[group.key].get_state(), STOPPED)
# trying to inject a non existing preset keeps the previous inejction
# alive
injector = daemon.injectors[group.key]
daemon.start_injecting(group.key, 'qux')
self.assertEqual(injector, daemon.injectors[group.key])
self.assertNotEqual(daemon.injectors[group.key].get_state(), STOPPED)
# trying to start injecting for an unknown device also just does
# nothing
daemon.start_injecting('quux', 'qux')
self.assertNotEqual(daemon.injectors[group.key].get_state(), STOPPED)
# after all that stuff autoload_history is still unharmed
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
# stop
daemon.stop_injecting(group.key)
self.assertNotIn(group.key, daemon.autoload_history._autoload_history)
self.assertEqual(daemon.injectors[group.key].get_state(), STOPPED)
self.assertTrue(daemon.autoload_history.may_autoload(
group.key, preset))
def test_daemon(self):
# remove the existing system mapping to force our own into it
if os.path.exists(get_config_path('xmodmap.json')):
os.remove(get_config_path('xmodmap.json'))
ev_1 = (EV_KEY, 9)
ev_2 = (EV_ABS, 12)
keycode_to_1 = 100
keycode_to_2 = 101
group = groups.find(name='Bar Device')
# unrelated group that shouldn't be affected at all
group2 = groups.find(name='gamepad')
custom_mapping.change(Key(*ev_1, 1), 'a')
custom_mapping.change(Key(*ev_2, -1), 'b')
system_mapping.clear()
# since this is in the same memory as the daemon, there is no need
# to save it to disk
system_mapping._set('a', keycode_to_1)
system_mapping._set('b', keycode_to_2)
preset = 'foo'
custom_mapping.save(group.get_preset_path(preset))
config.set_autoload_preset(group.key, preset)
"""injection 1"""
# should forward the event unchanged
push_events(group.key, [new_event(EV_KEY, 13, 1)])
self.daemon = Daemon()
self.daemon.set_config_dir(get_config_path())
self.assertFalse(uinput_write_history_pipe[0].poll())
self.daemon.start_injecting(group.key, preset)
self.assertEqual(self.daemon.get_state(group.key), STARTING)
self.assertEqual(self.daemon.get_state(group2.key), UNKNOWN)
event = uinput_write_history_pipe[0].recv()
self.assertEqual(self.daemon.get_state(group.key), RUNNING)
self.assertEqual(event.type, EV_KEY)
self.assertEqual(event.code, 13)
self.assertEqual(event.value, 1)
self.daemon.stop_injecting(group.key)
self.assertEqual(self.daemon.get_state(group.key), STOPPED)
time.sleep(0.1)
try:
self.assertFalse(uinput_write_history_pipe[0].poll())
except AssertionError:
print('Unexpected', uinput_write_history_pipe[0].recv())
# possibly a duplicate write!
raise
"""injection 2"""
# -1234 will be normalized to -1 by the injector
push_events(group.key, [new_event(*ev_2, -1234)])
self.daemon.start_injecting(group.key, preset)
time.sleep(0.1)
self.assertTrue(uinput_write_history_pipe[0].poll())
# the written key is a key-down event, not the original
# event value of -1234
event = uinput_write_history_pipe[0].recv()
self.assertEqual(event.type, EV_KEY)
self.assertEqual(event.code, keycode_to_2)
self.assertEqual(event.value, 1)
def test_get_config_path(self):
self.assertEqual(get_config_path(), tmp)
self.assertEqual(get_config_path('a', 'b'), os.path.join(tmp, 'a/b'))
