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)
