| # Copyright (c) 2012 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. |
| |
| """Touchpad device module provides some touchpad related attributes.""" |
| |
| import glob |
| import os |
| import re |
| |
| import common_util |
| |
| |
| class TouchpadDevice: |
| """A class about touchpad device properties.""" |
| |
| def __init__(self, device_node=None): |
| self.device_info_file = '/proc/bus/input/devices' |
| self.device_node = (device_node if device_node |
| else self.get_device_node()) |
| |
| def _re_str(self): |
| """Get the regular expression search string for a touchpad device.""" |
| pattern_str = ('touchpad', 'trackpad', 'cyapa') |
| return '(?:%s)' % '|'.join(pattern_str) |
| |
| def get_device_node(self): |
| """Get the touchpad device node through tpcontrol. |
| |
| tpcontrol returns a string like |
| Device Node (244): "/dev/input/event8" |
| """ |
| cmd = '/opt/google/touchpad/tpcontrol status | grep -i "device node"' |
| device_node_str = common_util.simple_system_output(cmd) |
| device_node = device_node_str.split(':')[-1].strip().strip('"') |
| return device_node |
| |
| def get_dimensions_in_mm(self): |
| """Get the width and height in mm of the device.""" |
| (left, right, top, bottom, |
| resolution_x, resolution_y) = self.get_resolutions() |
| width = float((right - left)) / resolution_x |
| height = float((bottom - top)) / resolution_y |
| return (width, height) |
| |
| def get_resolutions(self, device_description=None): |
| """Get the resolutions in x and y axis of the device.""" |
| _, _, _, _, resolution_x, resolution_y = self.get_abs_axes( |
| device_description) |
| return (resolution_x, resolution_y) |
| |
| def get_edges(self, device_description=None): |
| """Get the left, right, top, and bottom edges of the device.""" |
| left, right, top, bottom, _, _ = self.get_abs_axes( |
| device_description) |
| return (left, right, top, bottom) |
| |
| def get_abs_axes(self, device_description=None): |
| """Get information about min, max, and resolution from ABS_X and ABS_Y |
| |
| Example of ABS_X: |
| A: 00 0 1280 0 0 12 |
| Example of ABS_y: |
| A: 01 0 1280 0 0 12 |
| """ |
| pattern = 'A:\s*%s\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)' |
| pattern_x = pattern % '00' |
| pattern_y = pattern % '01' |
| cmd = 'evemu-describe %s' % self.device_node |
| if device_description is None: |
| device_description = common_util.simple_system_output(cmd) |
| found_x = found_y = False |
| left = right = top = bottom = None |
| resolution_x = resolution_y = None |
| if device_description: |
| for line in device_description.splitlines(): |
| if not found_x: |
| result = re.search(pattern_x, line, re.I) |
| if result: |
| left = int(result.group(1)) |
| right = int(result.group(2)) |
| resolution_x = int(result.group(5)) |
| found_x = True |
| if not found_y: |
| result = re.search(pattern_y, line, re.I) |
| if result: |
| top = int(result.group(1)) |
| bottom = int(result.group(2)) |
| resolution_y = int(result.group(5)) |
| found_y = True |
| return (left, right, top, bottom, resolution_x, resolution_y) |
| |
| def get_dimensions(self, device_description=None): |
| """Get the dimensions of the touchpad reported size.""" |
| left, right, top, bottom = self.get_edges(device_description) |
| return (right - left, bottom - top) |
| |
| def get_display_geometry(self, screen_size, display_ratio): |
| """Get a preferred display geometry when running the test.""" |
| display_ratio = 0.8 |
| dev_width, dev_height = self.get_dimensions() |
| screen_width, screen_height = screen_size |
| |
| if 1.0 * screen_width / screen_height <= 1.0 * dev_width / dev_height: |
| disp_width = int(screen_width * display_ratio) |
| disp_height = int(disp_width * dev_height / dev_width) |
| disp_offset_x = 0 |
| disp_offset_y = screen_height - disp_height |
| else: |
| disp_height = int(screen_height * display_ratio) |
| disp_width = int(disp_height * dev_width / dev_height) |
| disp_offset_x = 0 |
| disp_offset_y = screen_height - disp_height |
| |
| return (disp_width, disp_height, disp_offset_x, disp_offset_y) |
| |
| def _touchpad_input_name_re_str(self): |
| pattern_str = ('touchpad', 'trackpad') |
| return '(?:%s)' % '|'.join(pattern_str) |
| |
| def get_touchpad_input_dir(self): |
| """Get touchpad input directory.""" |
| input_root_dir = '/sys/class/input' |
| input_dirs = glob.glob(os.path.join(input_root_dir, 'input*')) |
| re_pattern = re.compile(self._touchpad_input_name_re_str(), re.I) |
| for input_dir in input_dirs: |
| filename = os.path.join(input_dir, 'name') |
| if os.path.isfile(filename): |
| with open(filename) as f: |
| for line in f: |
| if re_pattern.search(line) is not None: |
| return input_dir |
| return None |
| |
| def get_firmware_version(self): |
| """Probe the firmware version.""" |
| input_dir = self.get_touchpad_input_dir() |
| device_dir = 'device' |
| |
| # Get the re search pattern for firmware_version file name |
| fw_list = ('firmware', 'fw') |
| ver_list = ('version', 'id') |
| sep_list = ('_', '-') |
| re_str = '%s%s%s' % ('(?:%s)' % '|'.join(fw_list), |
| '(?:%s)' % '|'.join(sep_list), |
| '(?:%s)' % '|'.join(ver_list)) |
| re_pattern = re.compile(re_str, re.I) |
| |
| if input_dir is not None: |
| device_dir = os.path.join(input_dir, 'device', '*') |
| for f in glob.glob(device_dir): |
| if os.path.isfile(f) and re_pattern.search(f): |
| with open (f) as f: |
| for line in f: |
| return line.strip('\n') |
| return 'unknown' |
