touch_keyboard/uinputdevice.cc - chromiumos/platform2 - Git at Google

 // Copyright 2016 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.

 #include "touch_keyboard/uinputdevice.h"

 namespace touch_keyboard {

 // When creating a new uinput device, you must specify these parameters like
 // with an actual, physical device.  These are sane, safe values that we use
 // when creating a uinput device.
 constexpr int kGoogleVendorID = 0x18d1;
 constexpr int kDummyProductID = 0x00FF;
 constexpr int kVersionNumber = 1;

 // This is used when interpreting the results of ioctls that query the event
 // capabilities of a device.  They are returned in an int64_t bitfield.
 constexpr int kNumBitsPerInt = sizeof(int64_t) * 8;

 UinputDevice::~UinputDevice() {
   // Tell the OS to destroy the uinput device as this object is destructed.
   if (uinput_fd_ >= 0) {
     int error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_DESTROY);
     if (error) {
       PLOG(ERROR) << "Unable to destroy uinput device (" << error << ")";
     }
   }
 }

 bool UinputDevice::CreateUinputFD() {
   // Open a control file descriptor for creating a new uinput device.
   // This file descriptor is used with ioctls to configure the device and
   // receive the outgoing event information.
   if (uinput_fd_ >= 0) {
     LOG(ERROR) << "Control FD already opened! (" << uinput_fd_ << ") Quitting.";
     return false;
   }

   uinput_fd_ = syscall_handler_->open(kUinputControlFilename,
                                       O_WRONLY | O_NONBLOCK);
   if (uinput_fd_ < 0) {
     PLOG(ERROR) << "Unable to open " << kUinputControlFilename <<
                    " (" << uinput_fd_ << ")";
     return false;
   }
   LOG(INFO) << "Uinput control file descriptor opened (" << uinput_fd_ << ")";
   return true;
 }

 bool UinputDevice::EnableEventType(int ev_type) const {
   // Tell the kernel that this uinput device will report events of a
   // certain type (ABS, KEY, etc).  Individual event codes must still be
   // enabled individually, but their overarching types need to be enabled
   // first, which is done here.
   int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_EVBIT, ev_type);
   if (error) {
     LOG(ERROR) << "Unable to enable event type 0x" << std::hex << ev_type <<
                   "(" << std::dec << error << ")";
     return false;
   }
   LOG(INFO) << "Enabled events of type 0x" << std::hex << ev_type;
   return true;
 }

 bool UinputDevice::EnableKeyEvent(int ev_code) const {
   // Tell the kernel that this region's uinput device will report a specific
   // key event. (eg: KEY_BACKSPACE or BTN_TOUCH)
   int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_KEYBIT, ev_code);
   if (error) {
     LOG(ERROR) << "Unable to enable EV_KEY 0x" << std::hex << ev_code <<
                   " events (" << std::dec << ")";
     return false;
   }
   LOG(INFO) << "Enabled EV_KEY 0x" << std::hex << ev_code << " events";
   return true;
 }

 bool UinputDevice::EnableAbsEvent(int ev_code) const {
   // Tell the kernel that this region's uinput device will report a specific
   // kind of ABS event. (eg: ABS_MT_POSITION_X or ABS_PRESSURE)
   int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_ABSBIT, ev_code);
   if (error) {
     LOG(ERROR) << "Unable to enable EV_ABS 0x" << std::hex << ev_code <<
                   " events (" << std::dec << error << ")";
     return false;
   }
   LOG(INFO) << "Enabled EV_ABS 0x" << std::hex << ev_code << " events";
   return true;
 }

 bool UinputDevice::CopyABSOutputEvents(int source_evdev_fd,
                                        int width, int height) const {
   // Configure this region's uinput device to report the correct kinds of
   // events by copying the events that are reported by the input device
   // who's file descriptor is passed as a reference.
   // Instead of copying the range of the absolute axes though, the user
   // specifies the width and height manually -- essentially creating a
   // cloned input device with a different size than the source device.
   int ev_code, error;
   struct uinput_abs_setup abs_setup;
   int64_t supported_abs_event_codes[((KEY_MAX - 1) / kNumBitsPerInt) + 1];
   int64_t supported_event_types[EV_MAX];

   // Query the source evdev file descriptor to see which event types it
   // supports to make sure it supports ABS.
   memset(supported_event_types, 0, sizeof(supported_event_types));
   syscall_handler_->ioctl(source_evdev_fd, EVIOCGBIT(0, EV_MAX),
                           supported_event_types);
   if (!IsEventSupported(EV_ABS, supported_event_types)) {
     LOG(ERROR) << "Touchscreen does not support EV_ABS events.";
     return false;
   }

   // Enable the EV_ABS event type for this device.  Fail if it can't.
   if (!EnableEventType(EV_ABS)) {
     return false;
   }

   // Query the device to find which ABS event codes are supported and then
   // enable them for this uinput device as well.
   memset(supported_abs_event_codes, 0, sizeof(supported_abs_event_codes));
   syscall_handler_->ioctl(source_evdev_fd, EVIOCGBIT(EV_ABS, KEY_MAX),
                           supported_abs_event_codes);
   for (ev_code = 0; ev_code < KEY_MAX; ev_code++) {
     // Skip over any event codes that are not supported.
     if (!IsEventSupported(ev_code, supported_abs_event_codes)) {
       continue;
     }

     // Enable this event code for the uinput device.
     if (!EnableAbsEvent(ev_code)) {
       return false;
     }

     // Fill in the ranges for each EV_ABS axis, modifying them for X and Y.
     memset(&abs_setup, 0, sizeof(abs_setup));
     abs_setup.code = ev_code;
     syscall_handler_->ioctl(source_evdev_fd, EVIOCGABS(ev_code),
                             &abs_setup.absinfo);
     if (ev_code == ABS_MT_POSITION_X || ev_code == ABS_X) {
       abs_setup.absinfo.minimum = 0;
       abs_setup.absinfo.maximum = width;
     } else if (ev_code == ABS_MT_POSITION_Y || ev_code == ABS_Y) {
       abs_setup.absinfo.minimum = 0;
       abs_setup.absinfo.maximum = height;
     }
     error = syscall_handler_->ioctl(uinput_fd_, UI_ABS_SETUP, &abs_setup);
     if (error) {
       LOG(ERROR) << "Unable to set up axis for event code 0x" << std::hex <<
                     ev_code << " (" << std::dec << error << ")";
       return false;
     }
   }

   LOG(INFO) << "Successfully copied all EV_ABS events from source device";
   return true;
 }

 bool UinputDevice::FinalizeUinputCreation(
                                   std::string const &device_name) const {
   int error;
   struct uinput_setup device_info;

   // Build a uinput device struct and write it to the ui_fd to specify the
   // various identification parameters required such as the device name.
   memset(&device_info, 0, sizeof(device_info));
   snprintf(device_info.name, UINPUT_MAX_NAME_SIZE, "%s", device_name.c_str());
   device_info.id.bustype = BUS_USB;
   device_info.id.vendor  = kGoogleVendorID;
   device_info.id.product = kDummyProductID;
   device_info.id.version = kVersionNumber;
   error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_SETUP, &device_info);
   if (error) {
     LOG(ERROR) << "uinput device setup ioctl failed. (" << error << ")";
     return false;
   }

   // Finally request that a new uinput device is created to those specs.
   // After this step the device should be fully functional and ready to
   // send events.
   error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_CREATE);
   if (error) {
     LOG(ERROR) << "uinput device creation ioctl failed. (" << error << ")";
     return false;
   }

   LOG(INFO) << "Successfully finalized uinput device creation.";
   return true;
 }

 bool UinputDevice::SendEvent(int ev_type, int ev_code, int value) const {
   // Send an input event to the kernel through this uinput device.
   struct input_event ev;
   ev.type = ev_type;
   ev.code = ev_code;
   ev.value = value;

   int bytes_written =
           syscall_handler_->write(uinput_fd_, &ev, sizeof(struct input_event));
   if (bytes_written != sizeof(struct input_event)) {
     LOG(ERROR) << "Failed to write() when sending an event. (" <<
                   bytes_written << ")";
     return false;
   }
   return true;
 }

 bool UinputDevice::IsEventSupported(int event,
                                     int64_t *supported_event_types) const {
   // The array is essentially a big bit field and we're testing to see if
   // the event-th bit is set.  That tells us if the event type in question
   // is included in the support event types.
   return (supported_event_types[event / kNumBitsPerInt] >>
           (event % kNumBitsPerInt)) & 1;
 }

 }  // namespace touch_keyboard
	// Copyright 2016 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.

	#include "touch_keyboard/uinputdevice.h"

	namespace touch_keyboard {

	// When creating a new uinput device, you must specify these parameters like
	// with an actual, physical device. These are sane, safe values that we use
	// when creating a uinput device.
	constexpr int kGoogleVendorID = 0x18d1;
	constexpr int kDummyProductID = 0x00FF;
	constexpr int kVersionNumber = 1;

	// This is used when interpreting the results of ioctls that query the event
	// capabilities of a device. They are returned in an int64_t bitfield.
	constexpr int kNumBitsPerInt = sizeof(int64_t) * 8;

	UinputDevice::~UinputDevice() {
	// Tell the OS to destroy the uinput device as this object is destructed.
	if (uinput_fd_ >= 0) {
	int error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_DESTROY);
	if (error) {
	PLOG(ERROR) << "Unable to destroy uinput device (" << error << ")";
	}
	}
	}

	bool UinputDevice::CreateUinputFD() {
	// Open a control file descriptor for creating a new uinput device.
	// This file descriptor is used with ioctls to configure the device and
	// receive the outgoing event information.
	if (uinput_fd_ >= 0) {
	LOG(ERROR) << "Control FD already opened! (" << uinput_fd_ << ") Quitting.";
	return false;
	}

	uinput_fd_ = syscall_handler_->open(kUinputControlFilename,
	O_WRONLY \| O_NONBLOCK);
	if (uinput_fd_ < 0) {
	PLOG(ERROR) << "Unable to open " << kUinputControlFilename <<
	" (" << uinput_fd_ << ")";
	return false;
	}
	LOG(INFO) << "Uinput control file descriptor opened (" << uinput_fd_ << ")";
	return true;
	}

	bool UinputDevice::EnableEventType(int ev_type) const {
	// Tell the kernel that this uinput device will report events of a
	// certain type (ABS, KEY, etc). Individual event codes must still be
	// enabled individually, but their overarching types need to be enabled
	// first, which is done here.
	int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_EVBIT, ev_type);
	if (error) {
	LOG(ERROR) << "Unable to enable event type 0x" << std::hex << ev_type <<
	"(" << std::dec << error << ")";
	return false;
	}
	LOG(INFO) << "Enabled events of type 0x" << std::hex << ev_type;
	return true;
	}

	bool UinputDevice::EnableKeyEvent(int ev_code) const {
	// Tell the kernel that this region's uinput device will report a specific
	// key event. (eg: KEY_BACKSPACE or BTN_TOUCH)
	int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_KEYBIT, ev_code);
	if (error) {
	LOG(ERROR) << "Unable to enable EV_KEY 0x" << std::hex << ev_code <<
	" events (" << std::dec << ")";
	return false;
	}
	LOG(INFO) << "Enabled EV_KEY 0x" << std::hex << ev_code << " events";
	return true;
	}

	bool UinputDevice::EnableAbsEvent(int ev_code) const {
	// Tell the kernel that this region's uinput device will report a specific
	// kind of ABS event. (eg: ABS_MT_POSITION_X or ABS_PRESSURE)
	int error = syscall_handler_->ioctl(uinput_fd_, UI_SET_ABSBIT, ev_code);
	if (error) {
	LOG(ERROR) << "Unable to enable EV_ABS 0x" << std::hex << ev_code <<
	" events (" << std::dec << error << ")";
	return false;
	}
	LOG(INFO) << "Enabled EV_ABS 0x" << std::hex << ev_code << " events";
	return true;
	}

	bool UinputDevice::CopyABSOutputEvents(int source_evdev_fd,
	int width, int height) const {
	// Configure this region's uinput device to report the correct kinds of
	// events by copying the events that are reported by the input device
	// who's file descriptor is passed as a reference.
	// Instead of copying the range of the absolute axes though, the user
	// specifies the width and height manually -- essentially creating a
	// cloned input device with a different size than the source device.
	int ev_code, error;
	struct uinput_abs_setup abs_setup;
	int64_t supported_abs_event_codes[((KEY_MAX - 1) / kNumBitsPerInt) + 1];
	int64_t supported_event_types[EV_MAX];

	// Query the source evdev file descriptor to see which event types it
	// supports to make sure it supports ABS.
	memset(supported_event_types, 0, sizeof(supported_event_types));
	syscall_handler_->ioctl(source_evdev_fd, EVIOCGBIT(0, EV_MAX),
	supported_event_types);
	if (!IsEventSupported(EV_ABS, supported_event_types)) {
	LOG(ERROR) << "Touchscreen does not support EV_ABS events.";
	return false;
	}

	// Enable the EV_ABS event type for this device. Fail if it can't.
	if (!EnableEventType(EV_ABS)) {
	return false;
	}

	// Query the device to find which ABS event codes are supported and then
	// enable them for this uinput device as well.
	memset(supported_abs_event_codes, 0, sizeof(supported_abs_event_codes));
	syscall_handler_->ioctl(source_evdev_fd, EVIOCGBIT(EV_ABS, KEY_MAX),
	supported_abs_event_codes);
	for (ev_code = 0; ev_code < KEY_MAX; ev_code++) {
	// Skip over any event codes that are not supported.
	if (!IsEventSupported(ev_code, supported_abs_event_codes)) {
	continue;
	}

	// Enable this event code for the uinput device.
	if (!EnableAbsEvent(ev_code)) {
	return false;
	}

	// Fill in the ranges for each EV_ABS axis, modifying them for X and Y.
	memset(&abs_setup, 0, sizeof(abs_setup));
	abs_setup.code = ev_code;
	syscall_handler_->ioctl(source_evdev_fd, EVIOCGABS(ev_code),
	&abs_setup.absinfo);
	if (ev_code == ABS_MT_POSITION_X \|\| ev_code == ABS_X) {
	abs_setup.absinfo.minimum = 0;
	abs_setup.absinfo.maximum = width;
	} else if (ev_code == ABS_MT_POSITION_Y \|\| ev_code == ABS_Y) {
	abs_setup.absinfo.minimum = 0;
	abs_setup.absinfo.maximum = height;
	}
	error = syscall_handler_->ioctl(uinput_fd_, UI_ABS_SETUP, &abs_setup);
	if (error) {
	LOG(ERROR) << "Unable to set up axis for event code 0x" << std::hex <<
	ev_code << " (" << std::dec << error << ")";
	return false;
	}
	}

	LOG(INFO) << "Successfully copied all EV_ABS events from source device";
	return true;
	}

	bool UinputDevice::FinalizeUinputCreation(
	std::string const &device_name) const {
	int error;
	struct uinput_setup device_info;

	// Build a uinput device struct and write it to the ui_fd to specify the
	// various identification parameters required such as the device name.
	memset(&device_info, 0, sizeof(device_info));
	snprintf(device_info.name, UINPUT_MAX_NAME_SIZE, "%s", device_name.c_str());
	device_info.id.bustype = BUS_USB;
	device_info.id.vendor = kGoogleVendorID;
	device_info.id.product = kDummyProductID;
	device_info.id.version = kVersionNumber;
	error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_SETUP, &device_info);
	if (error) {
	LOG(ERROR) << "uinput device setup ioctl failed. (" << error << ")";
	return false;
	}

	// Finally request that a new uinput device is created to those specs.
	// After this step the device should be fully functional and ready to
	// send events.
	error = syscall_handler_->ioctl(uinput_fd_, UI_DEV_CREATE);
	if (error) {
	LOG(ERROR) << "uinput device creation ioctl failed. (" << error << ")";
	return false;
	}

	LOG(INFO) << "Successfully finalized uinput device creation.";
	return true;
	}

	bool UinputDevice::SendEvent(int ev_type, int ev_code, int value) const {
	// Send an input event to the kernel through this uinput device.
	struct input_event ev;
	ev.type = ev_type;
	ev.code = ev_code;
	ev.value = value;

	int bytes_written =
	syscall_handler_->write(uinput_fd_, &ev, sizeof(struct input_event));
	if (bytes_written != sizeof(struct input_event)) {
	LOG(ERROR) << "Failed to write() when sending an event. (" <<
	bytes_written << ")";
	return false;
	}
	return true;
	}

	bool UinputDevice::IsEventSupported(int event,
	int64_t *supported_event_types) const {
	// The array is essentially a big bit field and we're testing to see if
	// the event-th bit is set. That tells us if the event type in question
	// is included in the support event types.
	return (supported_event_types[event / kNumBitsPerInt] >>
	(event % kNumBitsPerInt)) & 1;
	}

	} // namespace touch_keyboard