• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "UinputDevice.h"
18 
19 #include <android-base/stringprintf.h>
20 #include <fcntl.h>
21 
22 namespace android {
23 
24 // --- UinputDevice ---
25 
UinputDevice(const char * name)26 UinputDevice::UinputDevice(const char* name) : mName(name) {}
27 
~UinputDevice()28 UinputDevice::~UinputDevice() {
29     if (ioctl(mDeviceFd, UI_DEV_DESTROY)) {
30         ALOGE("Error while destroying uinput device: %s", strerror(errno));
31     }
32     mDeviceFd.reset();
33 }
34 
init()35 void UinputDevice::init() {
36     mDeviceFd = android::base::unique_fd(open("/dev/uinput", O_WRONLY | O_NONBLOCK | O_CLOEXEC));
37     if (mDeviceFd < 0) {
38         FAIL() << "Can't open /dev/uinput :" << strerror(errno);
39     }
40 
41     struct uinput_user_dev device = {};
42     strlcpy(device.name, mName, UINPUT_MAX_NAME_SIZE);
43     device.id.bustype = BUS_USB;
44     device.id.vendor = 0x01;
45     device.id.product = 0x01;
46     device.id.version = 1;
47 
48     ASSERT_NO_FATAL_FAILURE(configureDevice(mDeviceFd, &device));
49 
50     if (write(mDeviceFd, &device, sizeof(device)) < 0) {
51         FAIL() << "Could not write uinput_user_dev struct into uinput file descriptor: "
52                << strerror(errno);
53     }
54 
55     if (ioctl(mDeviceFd, UI_DEV_CREATE)) {
56         FAIL() << "Error in ioctl : UI_DEV_CREATE: " << strerror(errno);
57     }
58 }
59 
injectEvent(uint16_t type,uint16_t code,int32_t value)60 void UinputDevice::injectEvent(uint16_t type, uint16_t code, int32_t value) {
61     struct input_event event = {};
62     event.type = type;
63     event.code = code;
64     event.value = value;
65     event.time = {}; // uinput ignores the timestamp
66 
67     if (write(mDeviceFd, &event, sizeof(input_event)) < 0) {
68         std::string msg = base::StringPrintf("Could not write event %" PRIu16 " %" PRIu16
69                                              " with value %" PRId32 " : %s",
70                                              type, code, value, strerror(errno));
71         ALOGE("%s", msg.c_str());
72         FAIL() << msg.c_str();
73     }
74 }
75 
76 // --- UinputKeyboard ---
77 
UinputKeyboard(std::initializer_list<int> keys)78 UinputKeyboard::UinputKeyboard(std::initializer_list<int> keys)
79       : UinputDevice(UinputKeyboard::KEYBOARD_NAME), mKeys(keys.begin(), keys.end()) {}
80 
configureDevice(int fd,uinput_user_dev * device)81 void UinputKeyboard::configureDevice(int fd, uinput_user_dev* device) {
82     // enable key press/release event
83     if (ioctl(fd, UI_SET_EVBIT, EV_KEY)) {
84         FAIL() << "Error in ioctl : UI_SET_EVBIT : EV_KEY: " << strerror(errno);
85     }
86 
87     // enable set of KEY events
88     std::for_each(mKeys.begin(), mKeys.end(), [fd](int key) {
89         if (ioctl(fd, UI_SET_KEYBIT, key)) {
90             FAIL() << "Error in ioctl : UI_SET_KEYBIT : " << key << " : " << strerror(errno);
91         }
92     });
93 
94     // enable synchronization event
95     if (ioctl(fd, UI_SET_EVBIT, EV_SYN)) {
96         FAIL() << "Error in ioctl : UI_SET_EVBIT : EV_SYN: " << strerror(errno);
97     }
98 }
99 
pressKey(int key)100 void UinputKeyboard::pressKey(int key) {
101     if (mKeys.find(key) == mKeys.end()) {
102         FAIL() << mName << ": Cannot inject key press: Key not found: " << key;
103     }
104     injectEvent(EV_KEY, key, 1);
105     injectEvent(EV_SYN, SYN_REPORT, 0);
106 }
107 
releaseKey(int key)108 void UinputKeyboard::releaseKey(int key) {
109     if (mKeys.find(key) == mKeys.end()) {
110         FAIL() << mName << ": Cannot inject key release: Key not found: " << key;
111     }
112     injectEvent(EV_KEY, key, 0);
113     injectEvent(EV_SYN, SYN_REPORT, 0);
114 }
115 
pressAndReleaseKey(int key)116 void UinputKeyboard::pressAndReleaseKey(int key) {
117     pressKey(key);
118     releaseKey(key);
119 }
120 
121 // --- UinputHomeKey ---
122 
UinputHomeKey()123 UinputHomeKey::UinputHomeKey() : UinputKeyboard({KEY_HOME}) {}
124 
pressAndReleaseHomeKey()125 void UinputHomeKey::pressAndReleaseHomeKey() {
126     pressAndReleaseKey(KEY_HOME);
127 }
128 
129 // --- UinputSteamController
UinputSteamController()130 UinputSteamController::UinputSteamController() : UinputKeyboard({BTN_GEAR_DOWN, BTN_GEAR_UP}) {}
131 
132 // --- UinputTouchScreen ---
UinputTouchScreen(const Rect * size)133 UinputTouchScreen::UinputTouchScreen(const Rect* size)
134       : UinputDevice(UinputTouchScreen::DEVICE_NAME), mSize(*size) {}
135 
configureDevice(int fd,uinput_user_dev * device)136 void UinputTouchScreen::configureDevice(int fd, uinput_user_dev* device) {
137     // Setup the touch screen device
138     ioctl(fd, UI_SET_EVBIT, EV_KEY);
139     ioctl(fd, UI_SET_EVBIT, EV_REL);
140     ioctl(fd, UI_SET_EVBIT, EV_ABS);
141     ioctl(fd, UI_SET_ABSBIT, ABS_MT_SLOT);
142     ioctl(fd, UI_SET_ABSBIT, ABS_MT_TOUCH_MAJOR);
143     ioctl(fd, UI_SET_ABSBIT, ABS_MT_POSITION_X);
144     ioctl(fd, UI_SET_ABSBIT, ABS_MT_POSITION_Y);
145     ioctl(fd, UI_SET_ABSBIT, ABS_MT_TRACKING_ID);
146     ioctl(fd, UI_SET_ABSBIT, ABS_MT_TOOL_TYPE);
147     ioctl(fd, UI_SET_PROPBIT, INPUT_PROP_DIRECT);
148     ioctl(fd, UI_SET_KEYBIT, BTN_TOUCH);
149 
150     device->absmin[ABS_MT_SLOT] = RAW_SLOT_MIN;
151     device->absmax[ABS_MT_SLOT] = RAW_SLOT_MAX;
152     device->absmin[ABS_MT_TOUCH_MAJOR] = RAW_TOUCH_MIN;
153     device->absmax[ABS_MT_TOUCH_MAJOR] = RAW_TOUCH_MAX;
154     device->absmin[ABS_MT_POSITION_X] = mSize.left;
155     device->absmax[ABS_MT_POSITION_X] = mSize.right - 1;
156     device->absmin[ABS_MT_POSITION_Y] = mSize.top;
157     device->absmax[ABS_MT_POSITION_Y] = mSize.bottom - 1;
158     device->absmin[ABS_MT_TRACKING_ID] = RAW_ID_MIN;
159     device->absmax[ABS_MT_TRACKING_ID] = RAW_ID_MAX;
160 }
161 
sendSlot(int32_t slot)162 void UinputTouchScreen::sendSlot(int32_t slot) {
163     injectEvent(EV_ABS, ABS_MT_SLOT, slot);
164 }
165 
sendTrackingId(int32_t trackingId)166 void UinputTouchScreen::sendTrackingId(int32_t trackingId) {
167     injectEvent(EV_ABS, ABS_MT_TRACKING_ID, trackingId);
168 }
169 
sendDown(const Point & point)170 void UinputTouchScreen::sendDown(const Point& point) {
171     injectEvent(EV_KEY, BTN_TOUCH, 1);
172     injectEvent(EV_ABS, ABS_MT_POSITION_X, point.x);
173     injectEvent(EV_ABS, ABS_MT_POSITION_Y, point.y);
174 }
175 
sendMove(const Point & point)176 void UinputTouchScreen::sendMove(const Point& point) {
177     injectEvent(EV_ABS, ABS_MT_POSITION_X, point.x);
178     injectEvent(EV_ABS, ABS_MT_POSITION_Y, point.y);
179 }
180 
sendPointerUp()181 void UinputTouchScreen::sendPointerUp() {
182     sendTrackingId(0xffffffff);
183 }
184 
sendUp()185 void UinputTouchScreen::sendUp() {
186     sendTrackingId(0xffffffff);
187     injectEvent(EV_KEY, BTN_TOUCH, 0);
188 }
189 
sendToolType(int32_t toolType)190 void UinputTouchScreen::sendToolType(int32_t toolType) {
191     injectEvent(EV_ABS, ABS_MT_TOOL_TYPE, toolType);
192 }
193 
sendSync()194 void UinputTouchScreen::sendSync() {
195     injectEvent(EV_SYN, SYN_REPORT, 0);
196 }
197 
198 // Get the center x, y base on the range definition.
getCenterPoint()199 const Point UinputTouchScreen::getCenterPoint() {
200     return Point(mSize.left + mSize.width() / 2, mSize.top + mSize.height() / 2);
201 }
202 
203 } // namespace android
204