| # Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| ''' A module for extracting trackpad device file properties ''' |
| |
| import logging |
| import os |
| |
| import constants |
| import trackpad_util |
| |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.bin.input.linux_input import * |
| from autotest_lib.client.common_lib import error |
| from trackpad_util import read_trackpad_test_conf, get_trackpad_device_file |
| |
| |
| # Declare NOP as a instance containing NOP related constants |
| NOP = constants.NOP() |
| |
| |
| class TrackpadDevice: |
| ''' Management of the trackpad device file |
| |
| It is used |
| (1) to extract trackpad device file properties such as device event |
| playback times, and |
| (2) to play back the device packets. The device file is usually |
| '/dev/input/event*'. |
| ''' |
| playback_program_default = 'evemu-play' |
| playback_program_emerged = '/usr/bin/evemu-play' |
| DEVICE_TIME_FILE = '/tmp/time.out' |
| |
| def __init__(self): |
| self._init_event_type_code() |
| self._init_event_structure() |
| self._set_dev_type_and_code() |
| if self._get_trackpad_driver() == 'synaptics': |
| self._ungrab_device() |
| self.trackpad_device_file, msg = get_trackpad_device_file() |
| if self.trackpad_device_file is None: |
| raise error.TestError(msg) |
| logging.info(msg) |
| |
| if os.path.isfile(self.playback_program_emerged): |
| self.playback_program = self.playback_program_emerged |
| else: |
| self.playback_program = self.playback_program_default |
| logging.info('Trackpad device playback program: %s' % |
| self.playback_program) |
| |
| def _init_event_type_code(self): |
| ''' Initialize event type and code ''' |
| self.ev_format = ev_format = '%04x' |
| |
| # Event types |
| self.EV_SYN = ev_format % EV_SYN |
| self.EV_KEY = ev_format % EV_KEY |
| self.EV_ABS = ev_format % EV_ABS |
| |
| # Event codes for synchronization event |
| self.SYN_REPORT = ev_format % SYN_REPORT |
| |
| # Event codes for absolute axes |
| self.ABS_MT_SLOT = ev_format % ABS_MT_SLOT |
| self.ABS_MT_TRACKING_ID = ev_format % ABS_MT_TRACKING_ID |
| |
| # Event codes for keys and buttons |
| self.BTN_MOUSE = ev_format % BTN_MOUSE |
| self.BTN_TOUCH = ev_format % BTN_TOUCH |
| self.BTN_TOOL_FINGER = ev_format % BTN_TOOL_FINGER |
| self.BTN_TOOL_DOUBLETAP = ev_format % BTN_TOOL_DOUBLETAP |
| self.BTN_TOOL_TRIPLETAP = ev_format % BTN_TOOL_TRIPLETAP |
| self.BTN_TOOL_QUADTAP = ev_format % BTN_TOOL_QUADTAP |
| |
| # Event codes for keys and buttons |
| self.ABS_X = ev_format % ABS_X |
| self.ABS_Y = ev_format % ABS_Y |
| self.ABS_PRESSURE = ev_format % ABS_PRESSURE |
| self.ABS_MT_SLOT = ev_format % ABS_MT_SLOT |
| self.ABS_MT_POSITION_X = ev_format % ABS_MT_POSITION_X |
| self.ABS_MT_POSITION_Y = ev_format % ABS_MT_POSITION_Y |
| self.ABS_MT_TRACKING_ID = ev_format % ABS_MT_TRACKING_ID |
| self.ABS_MT_PRESSURE = ev_format % ABS_MT_PRESSURE |
| |
| def _init_event_structure(self): |
| ev_type_code = '%s %s' |
| ev_struct = '%s %s %d' |
| self.finger_on = ev_struct % (self.EV_KEY, self.BTN_TOUCH, 1) |
| self.finger_off = ev_struct % (self.EV_KEY, self.BTN_TOUCH, 0) |
| self.mouse_click_press = ev_struct % (self.EV_KEY, self.BTN_MOUSE, 1) |
| self.mouse_click_release = ev_struct % (self.EV_KEY, self.BTN_MOUSE, 0) |
| self.one_finger_on = ev_struct % (self.EV_KEY, self.BTN_TOOL_FINGER, 1) |
| self.one_finger_off = ev_struct % (self.EV_KEY, self.BTN_TOOL_FINGER, 0) |
| self.two_fingers_on = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_DOUBLETAP, 1) |
| self.two_fingers_off = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_DOUBLETAP, 0) |
| self.three_fingers_on = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_TRIPLETAP, 1) |
| self.three_fingers_off = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_TRIPLETAP, 0) |
| self.four_fingers_on = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_QUADTAP, 1) |
| self.four_fingers_off = ev_struct % (self.EV_KEY, |
| self.BTN_TOOL_QUADTAP, 0) |
| self.tracking_id = ev_type_code % (self.EV_ABS, self.ABS_MT_TRACKING_ID) |
| self.slot = ev_type_code % (self.EV_ABS, self.ABS_MT_SLOT) |
| self.abs_mt_x = ev_type_code % (self.EV_ABS, self.ABS_MT_POSITION_X) |
| self.abs_mt_y = ev_type_code % (self.EV_ABS, self.ABS_MT_POSITION_Y) |
| self.abs_mt_z = ev_type_code % (self.EV_ABS, self.ABS_MT_PRESSURE) |
| self.abs_x = ev_type_code % (self.EV_ABS, self.ABS_X) |
| self.abs_y = ev_type_code % (self.EV_ABS, self.ABS_Y) |
| self.abs_z = ev_type_code % (self.EV_ABS, self.ABS_PRESSURE) |
| self.ev_syn = ev_type_code % (self.EV_SYN, self.SYN_REPORT) |
| |
| def _finger_i_on_MTB(self, i): |
| ''' The i-th finger touches the trackpad in MTB protocol ''' |
| return '%s %s %d' % (self.EV_ABS, self.ABS_MT_SLOT, i - 1) |
| |
| def _set_dev_type_and_code(self): |
| ''' Set device code |
| |
| Device event types and codes are imported from linux_input. |
| ''' |
| ev_code_x = self.ev_format % ABS_MT_POSITION_X |
| ev_code_y = self.ev_format % ABS_MT_POSITION_Y |
| self.ev_code_dict = {'left': (ev_code_x,), |
| 'right': (ev_code_x,), |
| 'up': (ev_code_y,), |
| 'down': (ev_code_y,), |
| None: (ev_code_x, ev_code_y)} |
| |
| # MTA: not supported at this time |
| |
| # MTB: the default MT type to use |
| self.second_finger_on_MTB = self._finger_i_on_MTB(2) |
| self.finger_off_MTB = '%s %s -1' % (self.EV_ABS, |
| self.ABS_MT_TRACKING_ID) |
| |
| finger_MTB = '{0} %s {1}' |
| finger_on_MTB = finger_MTB.format(self.EV_KEY, 1) |
| finger_off_MTB = finger_MTB.format(self.EV_KEY, 0) |
| |
| self.dev_event = { |
| NOP.FINGER1_LANDED: finger_on_MTB % self.BTN_TOOL_FINGER, |
| NOP.FINGER1_LIFTED: finger_off_MTB % self.BTN_TOOL_FINGER, |
| NOP.FINGER2_LANDED: finger_on_MTB % self.BTN_TOOL_DOUBLETAP, |
| NOP.FINGER2_LIFTED: finger_off_MTB % self.BTN_TOOL_DOUBLETAP, |
| NOP.FINGER3_LANDED: finger_on_MTB % self.BTN_TOOL_TRIPLETAP, |
| NOP.FINGER3_LIFTED: finger_off_MTB % self.BTN_TOOL_TRIPLETAP, |
| NOP.DEVICE_MOUSE_CLICK_PRESS: self.mouse_click_press, |
| NOP.DEVICE_MOUSE_CLICK_RELEASE: self.mouse_click_release, |
| NOP.FINGER_ON: self.finger_on, |
| NOP.FINGER_OFF: self.finger_off, |
| NOP.ONE_FINGER_ON: self.one_finger_on, |
| NOP.TWO_FINGERS_ON: self.two_fingers_on, |
| NOP.THREE_FINGERS_ON: self.three_fingers_on, |
| NOP.FOUR_FINGERS_ON: self.four_fingers_on, |
| } |
| |
| def _extract_playback_time(self, line): |
| ''' Extract the actual event playback time from the line ''' |
| return int(float(line.split('playback ')[1]) * 1000) |
| |
| def find_all_event_time(self, ev_str): |
| ''' Find the timestamps of all occurences of an event ''' |
| with open(TrackpadDevice.DEVICE_TIME_FILE) as f: |
| time_file = f.read().splitlines() |
| |
| ev = self.dev_event[ev_str] |
| time_list = [] |
| for line in time_file: |
| if ev in line: |
| time_list.append(self._extract_playback_time(line)) |
| return time_list |
| |
| def _find_event_time(self, ev_seq): |
| ''' Match the events in ev_seq against the device time file, and |
| return the timestamp of the first matched device events. |
| ''' |
| ev_seq_len = len(ev_seq) |
| if ev_seq_len == 0: |
| return None |
| |
| with open(TrackpadDevice.DEVICE_TIME_FILE) as f: |
| time_file = f.read().splitlines() |
| |
| ev = ev_seq.pop(0) |
| for line in time_file: |
| if ev in line: |
| if len(ev_seq) == 0: |
| return self._extract_playback_time(line) |
| ev = ev_seq.pop(0) |
| return None |
| |
| def get_finger_time(self, ev_str): |
| ''' Derive the device playback time of a specified event ''' |
| ev_seq_MTB = [self.dev_event[ev_str]] |
| ev_time = self._find_event_time(ev_seq_MTB) |
| return [ev_time] if ev_time is not None else [] |
| |
| def get_2nd_finger_touch_time(self, direction): |
| ''' Derive the device playback time when the 2nd finger touches ''' |
| ev_time = None |
| # When the functionality is 'two_fingers_no_delay_2d' in config file, |
| # check the ABS_MT_POSITION_X or ABS_MT_POSITION_Y event time. |
| # Use the timestamp which occurs earlier. |
| for ev_code in self.ev_code_dict[direction]: |
| motion_code = '%s %s' % (self.EV_ABS, ev_code) |
| ev_seq_MTB = [self.second_finger_on_MTB, motion_code] |
| new_ev_time = self._find_event_time(ev_seq_MTB) |
| ev_time = new_ev_time if ev_time is None else min(ev_time, |
| new_ev_time) |
| return ev_time |
| |
| def get_2nd_finger_lifted_time(self): |
| ''' Derive the device playback time when the 2nd finger is lifted ''' |
| ev_seq_MTB = [self.second_finger_on_MTB, self.finger_off_MTB] |
| return self._find_event_time(ev_seq_MTB) |
| |
| def get_two_finger_touch_time_list(self): |
| ''' Derive all device playback times when two fingers touch the pad ''' |
| with open(TrackpadDevice.DEVICE_TIME_FILE) as f: |
| time_file = f.read().splitlines() |
| |
| ev = self.dev_event[NOP.FINGER2_LANDED] |
| touch_time_list = [] |
| for line in time_file: |
| if ev in line: |
| touch_time_list.append(self._extract_playback_time(line)) |
| return touch_time_list |
| |
| def _get_trackpad_driver(self): |
| ''' Query which trackpad driver is used in xorg ''' |
| trackpad_drivers = read_trackpad_test_conf('trackpad_drivers', '.') |
| xorg_log = read_trackpad_test_conf('xorg_log', '.') |
| |
| try: |
| f = open(xorg_log) |
| except IOError: |
| raise error.TestError('Xorg log file %s does not exist.' % xorg_log) |
| log_lines = f.read().splitlines() |
| f.close() |
| |
| for line in log_lines: |
| if 'LoadModule' in line: |
| for driver in trackpad_drivers: |
| if driver in line: |
| logging.info('Trackpad driver "%s" is found.' % driver) |
| self.trackpad_driver = driver |
| return self.trackpad_driver |
| raise error.TestError('Cannot find driver in %s.' % |
| str(trackpad_drivers)) |
| |
| def _ungrab_device(self): |
| ''' Ungrab the device if the driver is synaptics and is grabbed ''' |
| self.grab_value = -1 |
| display_environ = trackpad_util.Display().get_environ() |
| synclient_list_cmd = ' '.join([display_environ, 'synclient -l']) |
| self.grab_device = ' '.join([display_environ, |
| 'synclient GrabEventDevice=%d']) |
| synclient_settings = utils.system_output(synclient_list_cmd) |
| for line in synclient_settings.splitlines(): |
| if line.lstrip().startswith('GrabEventDevice'): |
| self.grab_value = int(line.split('=')[1].strip()) |
| break |
| logging.info('GrabEventDevice=%d.' % self.grab_value) |
| if self.grab_value == -1: |
| err_msg = 'Cannot find GrabEventDevice setting in "%s".' |
| raise error.TestError(err_msg % synclient_list_cmd) |
| # Ungrab the device only if it has been grabbed. |
| elif self.grab_value == 1: |
| ungrab_cmd = self.grab_device % 0 |
| try: |
| utils.system(ungrab_cmd) |
| except: |
| raise error.TestError('Fail to execute: %s' % ungrab_cmd) |
| logging.info('The synaptics device file is ungrabbed now.') |
| |
| def playback(self, packet_data_file): |
| option_slot0 = '--insert-slot0' |
| option_output = '--output' |
| play_cmd = '%s %s %s %s %s < %s' % (self.playback_program, |
| self.trackpad_device_file, |
| option_slot0, |
| option_output, |
| TrackpadDevice.DEVICE_TIME_FILE, |
| packet_data_file) |
| utils.system(play_cmd) |
| |
| def __del__(self): |
| # Grab the device again only if it was originally grabbed. |
| if self.trackpad_driver == 'synaptics' and self.grab_value == 1: |
| grab_cmd = self.grab_device % 1 |
| try: |
| utils.system(grab_cmd) |
| except: |
| raise error.TestError('Fail to execute: %s' % grab_cmd) |
| logging.info('The synaptics device file is grabbed successfully.') |
| |
| # Remove the temporary device time file |
| if os.path.exists(TrackpadDevice.DEVICE_TIME_FILE): |
| try: |
| os.remove(TrackpadDevice.DEVICE_TIME_FILE) |
| except: |
| logging.warn('Cannot remove the device time file: %s.' % |
| TrackpadDevice.DEVICE_TIME_FILE) |
