1 /*
2 * Copyright (C) 2007 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 <dirent.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <linux/input.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/epoll.h>
25 #include <sys/inotify.h>
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29
30 #include <functional>
31 #include <memory>
32 #include <string>
33
34 #include <android-base/strings.h>
35 #include <android-base/unique_fd.h>
36
37 #include "minui/minui.h"
38
39 constexpr const char* INPUT_DEV_DIR = "/dev/input";
40
41 constexpr size_t MAX_DEVICES = 16;
42 constexpr size_t MAX_MISC_FDS = 16;
43
44 constexpr size_t BITS_PER_LONG = sizeof(unsigned long) * 8;
BITS_TO_LONGS(size_t bits)45 constexpr size_t BITS_TO_LONGS(size_t bits) {
46 return ((bits + BITS_PER_LONG - 1) / BITS_PER_LONG);
47 }
48
49 struct FdInfo {
50 android::base::unique_fd fd;
51 ev_callback cb;
52 };
53
54 static bool g_allow_touch_inputs = true;
55 static ev_callback g_saved_input_cb;
56 static android::base::unique_fd g_epoll_fd;
57 static epoll_event g_polled_events[MAX_DEVICES + MAX_MISC_FDS];
58 static int g_polled_events_count;
59
60 static FdInfo ev_fdinfo[MAX_DEVICES + MAX_MISC_FDS];
61
62 static size_t g_ev_count = 0;
63 static size_t g_ev_dev_count = 0;
64 static size_t g_ev_misc_count = 0;
65
test_bit(size_t bit,unsigned long * array)66 static bool test_bit(size_t bit, unsigned long* array) { // NOLINT
67 return (array[bit / BITS_PER_LONG] & (1UL << (bit % BITS_PER_LONG))) != 0;
68 }
69
should_add_input_device(int fd,bool allow_touch_inputs)70 static bool should_add_input_device(int fd, bool allow_touch_inputs) {
71 // Use unsigned long to match ioctl's parameter type.
72 unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)]; // NOLINT
73
74 // Read the evbits of the input device.
75 if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
76 return false;
77 }
78
79 // We assume that only EV_KEY, EV_REL, and EV_SW event types are ever needed. EV_ABS is also
80 // allowed if allow_touch_inputs is set.
81 if (!test_bit(EV_KEY, ev_bits) && !test_bit(EV_REL, ev_bits) && !test_bit(EV_SW, ev_bits)) {
82 if (!allow_touch_inputs || !test_bit(EV_ABS, ev_bits)) {
83 return false;
84 }
85 }
86
87 return true;
88 }
89
inotify_cb(int fd,__unused uint32_t epevents)90 static int inotify_cb(int fd, __unused uint32_t epevents) {
91 if (g_saved_input_cb == nullptr) return -1;
92
93 // The inotify will put one or several complete events.
94 // Should not read part of one event.
95 int event_len_int;
96 int ret = ioctl(fd, FIONREAD, &event_len_int);
97 if (ret != 0) return -1;
98 if (event_len_int < 0) return -1;
99 size_t event_len = event_len_int;
100
101 std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(INPUT_DEV_DIR), closedir);
102 if (!dir) {
103 return -1;
104 }
105
106 std::vector<int8_t> buf(event_len);
107
108 ssize_t r = TEMP_FAILURE_RETRY(read(fd, buf.data(), event_len));
109 if (r != event_len) {
110 return -1;
111 }
112
113 size_t offset = 0;
114 while (offset < event_len) {
115 struct inotify_event* pevent = reinterpret_cast<struct inotify_event*>(buf.data() + offset);
116 if (offset + sizeof(inotify_event) + pevent->len > event_len) {
117 // The pevent->len is too large and buffer will over flow.
118 // In general, should not happen, just make more stable.
119 return -1;
120 }
121 offset += sizeof(inotify_event) + pevent->len;
122
123 std::string event_name(pevent->name, pevent->len);
124 if (!android::base::StartsWith(event_name, "event")) {
125 continue;
126 }
127
128 android::base::unique_fd dfd(openat(dirfd(dir.get()), event_name.c_str(), O_RDONLY));
129 if (dfd == -1) {
130 break;
131 }
132
133 if (!should_add_input_device(dfd, g_allow_touch_inputs)) {
134 continue;
135 }
136
137 // Only add, we assume the user will not plug out and plug in USB device again and again :)
138 ev_add_fd(std::move(dfd), g_saved_input_cb);
139 }
140
141 return 0;
142 }
143
ev_init(ev_callback input_cb,bool allow_touch_inputs)144 int ev_init(ev_callback input_cb, bool allow_touch_inputs) {
145 g_epoll_fd.reset();
146
147 android::base::unique_fd epoll_fd(epoll_create1(EPOLL_CLOEXEC));
148 if (epoll_fd == -1) {
149 return -1;
150 }
151
152 android::base::unique_fd inotify_fd(inotify_init1(IN_CLOEXEC));
153 if (inotify_fd.get() == -1) {
154 return -1;
155 }
156
157 if (inotify_add_watch(inotify_fd, INPUT_DEV_DIR, IN_CREATE) < 0) {
158 return -1;
159 }
160
161 std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(INPUT_DEV_DIR), closedir);
162 if (!dir) {
163 return -1;
164 }
165
166 bool epoll_ctl_failed = false;
167 dirent* de;
168 while ((de = readdir(dir.get())) != nullptr) {
169 if (strncmp(de->d_name, "event", 5)) continue;
170 android::base::unique_fd fd(openat(dirfd(dir.get()), de->d_name, O_RDONLY | O_CLOEXEC));
171 if (fd == -1) continue;
172
173 if (!should_add_input_device(fd, allow_touch_inputs)) {
174 continue;
175 }
176
177 epoll_event ev;
178 ev.events = EPOLLIN | EPOLLWAKEUP;
179 ev.data.ptr = &ev_fdinfo[g_ev_count];
180 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
181 epoll_ctl_failed = true;
182 continue;
183 }
184
185 ev_fdinfo[g_ev_count].fd.reset(fd.release());
186 ev_fdinfo[g_ev_count].cb = input_cb;
187 g_ev_count++;
188 g_ev_dev_count++;
189 if (g_ev_dev_count == MAX_DEVICES) break;
190 }
191
192 if (epoll_ctl_failed && !g_ev_count) {
193 return -1;
194 }
195
196 g_epoll_fd.reset(epoll_fd.release());
197
198 g_saved_input_cb = input_cb;
199 g_allow_touch_inputs = allow_touch_inputs;
200 ev_add_fd(std::move(inotify_fd), inotify_cb);
201
202 return 0;
203 }
204
ev_get_epollfd(void)205 int ev_get_epollfd(void) {
206 return g_epoll_fd.get();
207 }
208
ev_add_fd(android::base::unique_fd && fd,ev_callback cb)209 int ev_add_fd(android::base::unique_fd&& fd, ev_callback cb) {
210 if (g_ev_misc_count == MAX_MISC_FDS || cb == nullptr) {
211 return -1;
212 }
213
214 epoll_event ev;
215 ev.events = EPOLLIN | EPOLLWAKEUP;
216 ev.data.ptr = static_cast<void*>(&ev_fdinfo[g_ev_count]);
217 int ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev);
218 if (!ret) {
219 ev_fdinfo[g_ev_count].fd.reset(fd.release());
220 ev_fdinfo[g_ev_count].cb = std::move(cb);
221 g_ev_count++;
222 g_ev_misc_count++;
223 }
224
225 return ret;
226 }
227
ev_exit(void)228 void ev_exit(void) {
229 while (g_ev_count > 0) {
230 ev_fdinfo[--g_ev_count].fd.reset();
231 }
232 g_ev_misc_count = 0;
233 g_ev_dev_count = 0;
234 g_saved_input_cb = nullptr;
235 g_epoll_fd.reset();
236 }
237
ev_wait(int timeout)238 int ev_wait(int timeout) {
239 g_polled_events_count = epoll_wait(g_epoll_fd, g_polled_events, g_ev_count, timeout);
240 if (g_polled_events_count <= 0) {
241 return -1;
242 }
243 return 0;
244 }
245
ev_dispatch(void)246 void ev_dispatch(void) {
247 for (int n = 0; n < g_polled_events_count; n++) {
248 FdInfo* fdi = static_cast<FdInfo*>(g_polled_events[n].data.ptr);
249 const ev_callback& cb = fdi->cb;
250 if (cb) {
251 cb(fdi->fd, g_polled_events[n].events);
252 }
253 }
254 }
255
ev_get_input(int fd,uint32_t epevents,input_event * ev)256 int ev_get_input(int fd, uint32_t epevents, input_event* ev) {
257 if (epevents & EPOLLIN) {
258 ssize_t r = TEMP_FAILURE_RETRY(read(fd, ev, sizeof(*ev)));
259 if (r == sizeof(*ev)) {
260 return 0;
261 }
262 }
263 if (epevents & EPOLLHUP) {
264 // Delete this watch
265 epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, nullptr);
266 }
267 return -1;
268 }
269
ev_sync_key_state(const ev_set_key_callback & set_key_cb)270 int ev_sync_key_state(const ev_set_key_callback& set_key_cb) {
271 // Use unsigned long to match ioctl's parameter type.
272 unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)]; // NOLINT
273 unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)]; // NOLINT
274
275 for (size_t i = 0; i < g_ev_dev_count; ++i) {
276 memset(ev_bits, 0, sizeof(ev_bits));
277 memset(key_bits, 0, sizeof(key_bits));
278
279 if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
280 continue;
281 }
282 if (!test_bit(EV_KEY, ev_bits)) {
283 continue;
284 }
285 if (ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits) == -1) {
286 continue;
287 }
288
289 for (int code = 0; code <= KEY_MAX; code++) {
290 if (test_bit(code, key_bits)) {
291 set_key_cb(code, 1);
292 }
293 }
294 }
295
296 return 0;
297 }
298
ev_iterate_available_keys(const std::function<void (int)> & f)299 void ev_iterate_available_keys(const std::function<void(int)>& f) {
300 // Use unsigned long to match ioctl's parameter type.
301 unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)]; // NOLINT
302 unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)]; // NOLINT
303
304 for (size_t i = 0; i < g_ev_dev_count; ++i) {
305 memset(ev_bits, 0, sizeof(ev_bits));
306 memset(key_bits, 0, sizeof(key_bits));
307
308 // Does this device even have keys?
309 if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
310 continue;
311 }
312 if (!test_bit(EV_KEY, ev_bits)) {
313 continue;
314 }
315
316 if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(EV_KEY, KEY_MAX), key_bits) == -1) {
317 continue;
318 }
319
320 for (int key_code = 0; key_code <= KEY_MAX; ++key_code) {
321 if (test_bit(key_code, key_bits)) {
322 f(key_code);
323 }
324 }
325 }
326 }
327
ev_iterate_touch_inputs(const std::function<void (int)> & action)328 void ev_iterate_touch_inputs(const std::function<void(int)>& action) {
329 for (size_t i = 0; i < g_ev_dev_count; ++i) {
330 // Use unsigned long to match ioctl's parameter type.
331 unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)] = {}; // NOLINT
332 if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
333 continue;
334 }
335 if (!test_bit(EV_ABS, ev_bits)) {
336 continue;
337 }
338
339 unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)] = {}; // NOLINT
340 if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(EV_ABS, KEY_MAX), key_bits) == -1) {
341 continue;
342 }
343
344 for (int key_code = 0; key_code <= KEY_MAX; ++key_code) {
345 if (test_bit(key_code, key_bits)) {
346 action(key_code);
347 }
348 }
349 }
350 }
351