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'))