def test_relative(self): """Check for relative events.""" uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(0, -1) expected_event = libevdev.InputEvent(libevdev.EV_REL.REL_Y, -1) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents((syn_event, expected_event), events) r = uhdev.event(1, 0) expected_event = libevdev.InputEvent(libevdev.EV_REL.REL_X, 1) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents((syn_event, expected_event), events) r = uhdev.event(-1, 2) expected_event0 = libevdev.InputEvent(libevdev.EV_REL.REL_X, -1) expected_event1 = libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents( (syn_event, expected_event0, expected_event1), events)
def test_two_keys(self): uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(['a and A', 'q and Q']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 1)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_A], 1) r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 0)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_A], 0) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_Q], 0) r = uhdev.event(['c and C']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_C], 1) r = uhdev.event(['c and C', 'Spacebar']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertNotIn(libevdev.InputEvent(libevdev.EV_KEY.KEY_C), events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_C], 1) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_SPACE], 1) r = uhdev.event(['Spacebar']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertNotIn(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE), events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_C], 0) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_SPACE], 1) r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_SPACE], 0)
def test_gyroscope(self): uhdev = self.uhdev evdev = uhdev.get_evdev("Accelerometer") for rx in range(-2000000, 2000000, 200000): r = uhdev.event(gyro=(rx, None, None)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RX) in events value = evdev.value[libevdev.EV_ABS.ABS_RX] # Sensor internal value is 16-bit, but calibrated is 22-bit, so # 6-bit (64) difference, so allow a range of +/- 64. assert rx - 64 <= value <= rx + 64 for ry in range(-2000000, 2000000, 200000): r = uhdev.event(gyro=(None, ry, None)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RY) in events value = evdev.value[libevdev.EV_ABS.ABS_RY] assert ry - 64 <= value <= ry + 64 for rz in range(-2000000, 2000000, 200000): r = uhdev.event(gyro=(None, None, rz)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RZ) in events value = evdev.value[libevdev.EV_ABS.ABS_RZ] assert rz - 64 <= value <= rz + 64
def test_single_fn_function_key_inverted(self): """check for function key reliability with the fn key.""" uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(['F4']) r.extend(uhdev.send_fn_state(1)) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_DASHBOARD, 1)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_FN, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert uhdev.evdev.value[libevdev.EV_KEY.KEY_DASHBOARD] == 1 r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_DASHBOARD, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert uhdev.evdev.value[libevdev.EV_KEY.KEY_DASHBOARD] == 0 assert uhdev.evdev.value[libevdev.EV_KEY.KEY_FN] == 1 r = uhdev.send_fn_state(0) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_FN, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events)
def test_accelerometer(self): uhdev = self.uhdev evdev = uhdev.get_evdev("Accelerometer") for x in range(-32000, 32000, 4000): r = uhdev.event(accel=(x, None, None)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_X) in events value = evdev.value[libevdev.EV_ABS.ABS_X] # Check against range due to small loss in precision due # to inverse calibration, followed by calibration by hid-sony. assert x - 1 <= value <= x + 1 for y in range(-32000, 32000, 4000): r = uhdev.event(accel=(None, y, None)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Y) in events value = evdev.value[libevdev.EV_ABS.ABS_Y] assert y - 1 <= value <= y + 1 for z in range(-32000, 32000, 4000): r = uhdev.event(accel=(None, None, z)) events = uhdev.next_sync_events("Accelerometer") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Z) in events value = evdev.value[libevdev.EV_ABS.ABS_Z] assert z - 1 <= value <= z + 1
def send_keys_up_and_reset(): # use glabal vars when assigning values global current_rect global current_pt global start_rect global start_numlock # if rect is valid if start_rect != None: list_size = len(start_rect) num_keys = (list_size - 4) rect_keys = start_rect[-num_keys:] # release all keys for rect for key in reversed(rect_keys): try: events = [ libevdev.InputEvent(key, 0), libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0) ] numpad.send_events(events) except OSError as err: logging.debug(str(err)) # reset variables current_pt = [-1, -1] start_rect = None current_rect = None start_numlock = 0
def test_two_keys(self): uhdev = self.uhdev evdev = uhdev.get_evdev() syn_event = self.syn_event r = uhdev.event(['a and A', 'q and Q']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 1)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_A] == 1 r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 0)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_Q, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_A] == 0 assert evdev.value[libevdev.EV_KEY.KEY_Q] == 0 r = uhdev.event(['c and C']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_C] == 1 r = uhdev.event(['c and C', 'Spacebar']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.KEY_C) not in events self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_C] == 1 assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 1 r = uhdev.event(['Spacebar']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_C, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE) not in events self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_C] == 0 assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 1 r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_SPACE, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_SPACE] == 0
def press(key): press = [ libevdev.InputEvent(key, value=1), libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, value=0) ] uinput.send_events(press) press = [ libevdev.InputEvent(key, value=0), libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, value=0) ] uinput.send_events(press)
def test_modifiers(self): # ctrl-alt-del would be very nice :) uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(['LeftControl', 'LeftShift', '= and +']) expected = [syn_event] expected.append( libevdev.InputEvent(libevdev.EV_KEY.KEY_LEFTCTRL, 1)) expected.append( libevdev.InputEvent(libevdev.EV_KEY.KEY_LEFTSHIFT, 1)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_EQUAL, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events)
def pipe_device(args, remote_device, local_device): """ Pipe events from a remote device to a local device. Args: args: argparse arguments remote_device (paramiko.ChannelFile): read-only stream of input events local_device: local virtual input device to write events to """ import libevdev # While debug mode is active, we log events grouped together between # SYN_REPORT events. Pending events for the next log are stored here pending_events = [] while True: e_time, e_millis, e_type, e_code, e_value = struct.unpack( '2IHHi', remote_device.read(16)) e_bit = libevdev.evbit(e_type, e_code) event = libevdev.InputEvent(e_bit, value=e_value) local_device.send_events([event]) if args.debug: if e_bit == libevdev.EV_SYN.SYN_REPORT: event_repr = ', '.join( '{} = {}'.format(event.code.name, event.value) for event in pending_events) log.debug('{}.{:0>6} - {}'.format(e_time, e_millis, event_repr)) pending_events = [] else: pending_events += [event]
def read_tablet(rm_inputs, *, orientation, monitor_num, region, threshold, mode): """Loop forever and map evdev events to mouse Args: rm_inputs (dictionary of paramiko.ChannelFile): dict of pen, button and touch input streams orientation (str): tablet orientation monitor_num (int): monitor number to map to region (boolean): whether to selection mapping region with region tool threshold (int): pressure threshold mode (str): mapping mode """ from pynput.mouse import Button, Controller mouse = Controller() monitor = get_monitor(region, monitor_num, orientation) log.debug('Chose monitor: {}'.format(monitor)) x = y = 0 while True: _, _, e_type, e_code, e_value = struct.unpack( '2IHHi', rm_inputs['pen'].read(16)) e_bit = libevdev.evbit(e_type, e_code) e = libevdev.InputEvent(e_bit, value=e_value) if e.matches(EV_ABS): # handle x direction if e.matches(EV_ABS.ABS_Y): log.debug(e.value) x = e.value # handle y direction if e.matches(EV_ABS.ABS_X): log.debug('\t{}'.format(e.value)) y = e.value # handle draw if e.matches(EV_KEY.BTN_TOUCH): log.debug('\t\t{}'.format(e.value)) if e.value == 1: log.debug('PRESS') mouse.press(Button.left) else: log.debug('RELEASE') mouse.release(Button.left) if e.matches(EV_SYN): mapped_x, mapped_y = remap(x, y, wacom_width, wacom_height, monitor.width, monitor.height, mode, orientation) mouse.move(monitor.x + mapped_x - mouse.position[0], monitor.y + mapped_y - mouse.position[1])
def move_y(self, abs_y): """ Send ABS_Y event on virtual tablet device, with value abs_y """ self.send_events([ libevdev.InputEvent(libevdev.EV_ABS.ABS_Y, value=abs_y), #libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, # value=0), ])
def change_pressure(self, pressure): """ Send an ABS_PRESSURE event on the virtual tablet device """ self.send_events([ libevdev.InputEvent(libevdev.EV_ABS.ABS_PRESSURE, value=pressure), #libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, # value=0), ])
def write_events(self, events: List["Ev"]): """ Write the list of events to the uinput device. If a SYN_REPORT is not the last element in the event list, it is automatically appended. """ last = events[-1].libevdev_event if last.code != libevdev.EV_SYN.SYN_REPORT: events += [libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0)] self.uidev.send_events([e.libevdev_event for e in events])
def test_hat_switch(self, hat_value, expected_evdev, evdev_value): uhdev = self.uhdev r = uhdev.event(hat_switch=hat_value) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) assert libevdev.InputEvent( libevdev.evbit('EV_ABS', expected_evdev), evdev_value) in events
def _test_joystick_press(self, which, data): uhdev = self.uhdev libevdev_axes = self._get_libevdev_abs_events(which) r = None if which == 'left_stick': r = uhdev.event(left=data) else: r = uhdev.event(right=data) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) for i, d in enumerate(data): if d is not None and d != 127: assert libevdev.InputEvent(libevdev_axes[i], d) in events else: assert libevdev.InputEvent(libevdev_axes[i]) not in events
def send_state_no_pos(self, is_away=False): """ Updates state of virtual tablet device using is_touching, is_away, pressed_button_1 and pressed_button_2 """ self.lastmodif = datetime.datetime.now() self.is_away = is_away print("Away: {}, Touching: {}".format(self.is_away, self.is_touching)) self.uinput.send_events([ libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, value=1 if self.is_touching else 0), libevdev.InputEvent(libevdev.EV_KEY.BTN_TOOL_PEN, value=1 if not self.is_away else 0), libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS, value=1 if self.pressed_button_1 else 0), libevdev.InputEvent(libevdev.EV_KEY.BTN_STYLUS2, value=1 if self.pressed_button_2 else 0), #Syn_report here, I'm leaving it in because I don't know if the input driver sends a syn_report here or not libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, value=0), ])
def send_keys_down(): # if rect is valid if start_rect != None: list_size = len(start_rect) num_keys = (list_size - 4) rect_keys = start_rect[-num_keys:] # press all keys for rect for key in rect_keys: try: events = [ libevdev.InputEvent(key, 1), libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0) ] numpad.send_events(events) time.sleep(0.2) except OSError as err: logging.debug(str(err))
def read_tablet(rm_inputs, *, orientation, monitor, threshold, mode): """Pipe rM evdev events to local device Args: rm_inputs (dictionary of paramiko.ChannelFile): dict of pen, button and touch input streams orientation (str): tablet orientation monitor (int): monitor number to map to threshold (int): pressure threshold mode (str): mapping mode """ local_device = create_local_device() log.debug("Created virtual input device '{}'".format(local_device.devnode)) configure_xinput( orientation=orientation, monitor=monitor, threshold=threshold, mode=mode, ) import libevdev pending_events = [] # loop inputs forever # for input_name, stream in cycle(rm_inputs.items()): stream = rm_inputs['pen'] while True: try: data = stream.read(16) except TimeoutError: continue e_time, e_millis, e_type, e_code, e_value = struct.unpack( '2IHHi', data) e_bit = libevdev.evbit(e_type, e_code) event = libevdev.InputEvent(e_bit, value=e_value) local_device.send_events([event]) # While debug mode is active, we log events grouped together between # SYN_REPORT events. Pending events for the next log are stored here if log.level == logging.DEBUG: if e_bit == libevdev.EV_SYN.SYN_REPORT: event_repr = ', '.join( '{} = {}'.format(event.code.name, event.value) for event in pending_events) log.debug('{}.{:0>6} - {}'.format(e_time, e_millis, event_repr)) pending_events = [] else: pending_events.append(event)
def test_single_key(self): """check for key reliability.""" uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(['a and A']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_A], 1) r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_A, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) self.assertEqual(uhdev.evdev.value[libevdev.EV_KEY.KEY_A], 0)
def assertInputEvents(self, expected_events, effective_events): # Buttons and x/y are spread over two HID reports, so we can get two # event frames for this device. remaining = self.assertInputEventsIn(expected_events, effective_events) try: remaining.remove(libevdev.InputEvent(libevdev.EV_SYN.SYN_REPORT, 0)) except ValueError: # If there's no SYN_REPORT in the list, continue and let the # assert below print out the real error pass assert remaining == []
def test_dual_buttons(self): """check for button reliability when pressing 2 buttons""" uhdev = self.uhdev evdev = uhdev.get_evdev() syn_event = self.syn_event # can change intended b1 b2 values b1 = uhdev.buttons[0] key1 = libevdev.evbit(uhdev.buttons_map[b1]) b2 = uhdev.buttons[1] key2 = libevdev.evbit(uhdev.buttons_map[b2]) buttons = {b1: True, b2: True} r = uhdev.event(buttons=buttons) expected_event0 = libevdev.InputEvent(key1, 1) expected_event1 = libevdev.InputEvent(key2, 1) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn( (syn_event, expected_event0, expected_event1), events) assert evdev.value[key1] == 1 assert evdev.value[key2] == 1 buttons = {b1: False, b2: None} r = uhdev.event(buttons=buttons) r = uhdev.event(buttons={b1: False, b2: None}) expected_event = libevdev.InputEvent(key1, 0) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn((syn_event, expected_event), events) assert evdev.value[key1] == 0 assert evdev.value[key2] == 1 buttons = {b1: None, b2: False} r = uhdev.event(buttons=buttons) expected_event = libevdev.InputEvent(key2, 0) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn((syn_event, expected_event), events) assert evdev.value[key1] == 0 assert evdev.value[key2] == 0
def events(): """ Yields the next event in the recording """ for event in device["events"]: for evdev in event.get("evdev", []): yield libevdev.InputEvent( code=libevdev.evbit(evdev[2], evdev[3]), value=evdev[4], sec=evdev[0], usec=evdev[1], )
def test_wifi_key(self): uhdev = self.uhdev syn_event = self.syn_event # the following sends a 'release' event on the Wifi key. # the kernel is supposed to translate this into Wifi key # down and up r = [0x03, 0x00] uhdev.call_input_event(r) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_RFKILL, 1)) events = uhdev.next_sync_events() self.debug_reports([r], uhdev, events) self.assertInputEventsIn(expected, events) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_RFKILL, 0)) # the kernel sends the two down/up key events in a batch, no need to # call events = uhdev.next_sync_events() self.debug_reports([], uhdev, events) self.assertInputEventsIn(expected, events)
def test_single_function_key(self): """check for function key reliability.""" uhdev = self.uhdev syn_event = self.syn_event r = uhdev.event(['F4']) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_DASHBOARD, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert uhdev.evdev.value[libevdev.EV_KEY.KEY_DASHBOARD] == 1 assert uhdev.evdev.value[libevdev.EV_KEY.KEY_FN] == 0 r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_DASHBOARD, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert uhdev.evdev.value[libevdev.EV_KEY.KEY_DASHBOARD] == 0
def assert_button(self, button): uhdev = self.uhdev syn_event = self.syn_event buttons = {} key = libevdev.evbit(uhdev.buttons_map[button]) buttons[button] = True r = uhdev.event(buttons=buttons) expected_event = libevdev.InputEvent(key, 1) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn((syn_event, expected_event), events) assert uhdev.evdev.value[key] == 1 buttons[button] = False r = uhdev.event(buttons=buttons) expected_event = libevdev.InputEvent(key, 0) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn((syn_event, expected_event), events) assert uhdev.evdev.value[key] == 0
def test_mt_single_touch(self): """send a single touch in the first slot of the device, and release it.""" uhdev = self.uhdev evdev = uhdev.get_evdev("Touch Pad") t0 = PSTouchPoint(1, 50, 100) r = uhdev.event(touch=[t0]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 t0.tipswitch = False r = uhdev.event(touch=[t0]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 0) in events assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
def test_mt_dual_touch(self): """Send 2 touches in the first 2 slots. Make sure the kernel sees this as a dual touch. Release and check Note: PTP will send here BTN_DOUBLETAP emulation""" uhdev = self.uhdev evdev = uhdev.get_evdev("Touch Pad") t0 = PSTouchPoint(1, 50, 100) t1 = PSTouchPoint(2, 150, 200) r = uhdev.event(touch=[t0]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 r = uhdev.event(touch=[t0, t1]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH) not in events assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_X, 5) not in events assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_Y, 10) not in events assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_X] == 150 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 200 t0.tipswitch = False r = uhdev.event(touch=[t0, t1]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1 assert libevdev.InputEvent( libevdev.EV_ABS.ABS_MT_POSITION_X) not in events assert libevdev.InputEvent( libevdev.EV_ABS.ABS_MT_POSITION_Y) not in events t1.tipswitch = False r = uhdev.event(touch=[t1]) events = uhdev.next_sync_events("Touch Pad") self.debug_reports(r, uhdev, events) assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
def test_single_pageup_key_release_first(self): """check for function key reliability with the [page] up key.""" uhdev = self.uhdev evdev = uhdev.get_evdev() syn_event = self.syn_event r = uhdev.send_fn_state(1) r.extend(uhdev.event(['UpArrow'])) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_PAGEUP, 1)) expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_FN, 1)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_PAGEUP] == 1 assert evdev.value[libevdev.EV_KEY.KEY_UP] == 0 assert evdev.value[libevdev.EV_KEY.KEY_FN] == 1 r = uhdev.send_fn_state(0) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_FN, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_PAGEUP] == 1 assert evdev.value[libevdev.EV_KEY.KEY_UP] == 0 assert evdev.value[libevdev.EV_KEY.KEY_FN] == 0 r = uhdev.event([]) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_KEY.KEY_PAGEUP, 0)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEventsIn(expected, events) assert evdev.value[libevdev.EV_KEY.KEY_PAGEUP] == 0 assert evdev.value[libevdev.EV_KEY.KEY_UP] == 0 assert evdev.value[libevdev.EV_KEY.KEY_FN] == 0
def test_wheel(self): uhdev = self.uhdev # check if the kernel is high res wheel compatible high_res_wheel = self.is_wheel_highres(uhdev) syn_event = self.syn_event # The Resolution Multiplier is applied to the HID reports, so we # need to pre-multiply too. mult = uhdev.wheel_multiplier r = uhdev.event(0, 0, wheels=1 * mult) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, 1)) if high_res_wheel: expected.append( libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 120)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents(expected, events) r = uhdev.event(0, 0, wheels=-1 * mult) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, -1)) if high_res_wheel: expected.append( libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, -120)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents(expected, events) r = uhdev.event(-1, 2, wheels=3 * mult) expected = [syn_event] expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_X, -1)) expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_Y, 2)) expected.append(libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL, 3)) if high_res_wheel: expected.append( libevdev.InputEvent(libevdev.EV_REL.REL_WHEEL_HI_RES, 360)) events = uhdev.next_sync_events() self.debug_reports(r, uhdev, events) self.assertInputEvents(expected, events)