Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 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> |
Dan Albert | c8686b4 | 2017-10-11 11:47:54 -0700 | [diff] [blame] | 18 | #include <errno.h> |
Elliott Hughes | 25a29d4 | 2017-02-23 10:45:42 -0800 | [diff] [blame] | 19 | #include <fcntl.h> |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 20 | #include <linux/input.h> |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 21 | #include <stdio.h> |
| 22 | #include <stdlib.h> |
| 23 | #include <string.h> |
| 24 | #include <sys/epoll.h> |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 25 | #include <sys/inotify.h> |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 26 | #include <sys/ioctl.h> |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 27 | #include <sys/types.h> |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 28 | #include <unistd.h> |
| 29 | |
Tao Bao | 9468fc0 | 2017-03-17 00:57:37 -0700 | [diff] [blame] | 30 | #include <functional> |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 31 | #include <memory> |
Christopher Ferris | 187a6ec | 2021-10-08 12:05:31 -0700 | [diff] [blame^] | 32 | #include <string> |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 33 | |
Christopher Ferris | 187a6ec | 2021-10-08 12:05:31 -0700 | [diff] [blame^] | 34 | #include <android-base/strings.h> |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 35 | #include <android-base/unique_fd.h> |
Tao Bao | 9468fc0 | 2017-03-17 00:57:37 -0700 | [diff] [blame] | 36 | |
Tao Bao | 0ecbd76 | 2017-01-16 21:16:58 -0800 | [diff] [blame] | 37 | #include "minui/minui.h" |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 38 | |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 39 | constexpr const char* INPUT_DEV_DIR = "/dev/input"; |
| 40 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 41 | constexpr size_t MAX_DEVICES = 16; |
| 42 | constexpr size_t MAX_MISC_FDS = 16; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 43 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 44 | constexpr size_t BITS_PER_LONG = sizeof(unsigned long) * 8; |
| 45 | constexpr size_t BITS_TO_LONGS(size_t bits) { |
| 46 | return ((bits + BITS_PER_LONG - 1) / BITS_PER_LONG); |
| 47 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 48 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 49 | struct FdInfo { |
| 50 | android::base::unique_fd fd; |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 51 | ev_callback cb; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 52 | }; |
| 53 | |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 54 | static bool g_allow_touch_inputs = true; |
| 55 | static ev_callback g_saved_input_cb; |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 59 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 60 | static FdInfo ev_fdinfo[MAX_DEVICES + MAX_MISC_FDS]; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 61 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 65 | |
Chih-Hung Hsieh | 54a2747 | 2016-04-18 11:30:55 -0700 | [diff] [blame] | 66 | static bool test_bit(size_t bit, unsigned long* array) { // NOLINT |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 67 | return (array[bit / BITS_PER_LONG] & (1UL << (bit % BITS_PER_LONG))) != 0; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 68 | } |
| 69 | |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 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 | |
| 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. |
Stephane Lee | 12952cd | 2020-01-13 15:46:36 -0800 | [diff] [blame] | 95 | int event_len_int; |
| 96 | int ret = ioctl(fd, FIONREAD, &event_len_int); |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 97 | if (ret != 0) return -1; |
Stephane Lee | 12952cd | 2020-01-13 15:46:36 -0800 | [diff] [blame] | 98 | if (event_len_int < 0) return -1; |
| 99 | size_t event_len = event_len_int; |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 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 | |
Christopher Ferris | 187a6ec | 2021-10-08 12:05:31 -0700 | [diff] [blame^] | 123 | std::string event_name(pevent->name, pevent->len); |
| 124 | if (!android::base::StartsWith(event_name, "event")) { |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 125 | continue; |
| 126 | } |
| 127 | |
Christopher Ferris | 187a6ec | 2021-10-08 12:05:31 -0700 | [diff] [blame^] | 128 | android::base::unique_fd dfd(openat(dirfd(dir.get()), event_name.c_str(), O_RDONLY)); |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 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 | |
Tao Bao | 5f8dd99 | 2017-07-28 00:05:40 -0700 | [diff] [blame] | 144 | int ev_init(ev_callback input_cb, bool allow_touch_inputs) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 145 | g_epoll_fd.reset(); |
| 146 | |
| 147 | android::base::unique_fd epoll_fd(epoll_create1(EPOLL_CLOEXEC)); |
| 148 | if (epoll_fd == -1) { |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 149 | return -1; |
| 150 | } |
| 151 | |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 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); |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 162 | if (!dir) { |
| 163 | return -1; |
| 164 | } |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 165 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Tao Bao | 5f8dd99 | 2017-07-28 00:05:40 -0700 | [diff] [blame] | 172 | |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 173 | if (!should_add_input_device(fd, allow_touch_inputs)) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 174 | continue; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 175 | } |
| 176 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 190 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 191 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 192 | if (epoll_ctl_failed && !g_ev_count) { |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 193 | return -1; |
| 194 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 195 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 196 | g_epoll_fd.reset(epoll_fd.release()); |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 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 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 202 | return 0; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | int ev_get_epollfd(void) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 206 | return g_epoll_fd.get(); |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 209 | int ev_add_fd(android::base::unique_fd&& fd, ev_callback cb) { |
| 210 | if (g_ev_misc_count == MAX_MISC_FDS || cb == nullptr) { |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 211 | return -1; |
| 212 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 213 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 214 | epoll_event ev; |
| 215 | ev.events = EPOLLIN | EPOLLWAKEUP; |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 216 | ev.data.ptr = static_cast<void*>(&ev_fdinfo[g_ev_count]); |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 217 | int ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev); |
| 218 | if (!ret) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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++; |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 223 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 224 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 225 | return ret; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | void ev_exit(void) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 234 | g_saved_input_cb = nullptr; |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 235 | g_epoll_fd.reset(); |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | int ev_wait(int timeout) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | void ev_dispatch(void) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 247 | for (int n = 0; n < g_polled_events_count; n++) { |
| 248 | FdInfo* fdi = static_cast<FdInfo*>(g_polled_events[n].data.ptr); |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 249 | const ev_callback& cb = fdi->cb; |
| 250 | if (cb) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 251 | cb(fdi->fd, g_polled_events[n].events); |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 252 | } |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 253 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 254 | } |
| 255 | |
Elliott Hughes | 07cfb8f | 2015-04-10 13:12:05 -0700 | [diff] [blame] | 256 | int ev_get_input(int fd, uint32_t epevents, input_event* ev) { |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 257 | if (epevents & EPOLLIN) { |
| 258 | ssize_t r = TEMP_FAILURE_RETRY(read(fd, ev, sizeof(*ev))); |
| 259 | if (r == sizeof(*ev)) { |
| 260 | return 0; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 261 | } |
Xihua Chen | a7952ac | 2018-01-12 13:42:18 +0800 | [diff] [blame] | 262 | } |
| 263 | if (epevents & EPOLLHUP) { |
| 264 | // Delete this watch |
| 265 | epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, nullptr); |
| 266 | } |
| 267 | return -1; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 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 |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 274 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 275 | for (size_t i = 0; i < g_ev_dev_count; ++i) { |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 276 | memset(ev_bits, 0, sizeof(ev_bits)); |
| 277 | memset(key_bits, 0, sizeof(key_bits)); |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 278 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 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; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 287 | } |
| 288 | |
Tao Bao | 0b1118d | 2017-01-14 07:46:10 -0800 | [diff] [blame] | 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; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Chih-Hung Hsieh | 23abfd3 | 2016-07-27 10:19:47 -0700 | [diff] [blame] | 299 | void ev_iterate_available_keys(const std::function<void(int)>& f) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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 |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 303 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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)); |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 307 | |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 308 | // Does this device even have keys? |
| 309 | if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) { |
| 310 | continue; |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 311 | } |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 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 | } |
Elliott Hughes | 0713819 | 2015-04-10 09:40:53 -0700 | [diff] [blame] | 326 | } |
Tao Bao | 5f8dd99 | 2017-07-28 00:05:40 -0700 | [diff] [blame] | 327 | |
| 328 | void ev_iterate_touch_inputs(const std::function<void(int)>& action) { |
Tao Bao | 835bf09 | 2019-03-11 14:13:21 -0700 | [diff] [blame] | 329 | for (size_t i = 0; i < g_ev_dev_count; ++i) { |
Tao Bao | 5f8dd99 | 2017-07-28 00:05:40 -0700 | [diff] [blame] | 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 | } |