| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <linux/input.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <sys/poll.h> |
| #include <unistd.h> |
| |
| #include <string> |
| #include <vector> |
| |
| using std::string; |
| using std::vector; |
| |
| static const int kMaxDeviceName = 80; |
| |
| // Reads the list of files in |directory_path| into |filenames|. |
| void ListDirectory(const string& directory_path, vector<string>* filenames) { |
| if (!filenames) { |
| printf("Error: filenames is null.\n"); |
| exit(1); |
| } |
| DIR* directory = opendir(directory_path.c_str()); |
| if (!directory) { |
| printf("Failed to open %s.\n", directory_path.c_str()); |
| return; |
| } |
| struct dirent *entry = NULL; |
| while ((entry = readdir(directory))) { |
| if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) { |
| filenames->push_back(directory_path + "/" + entry->d_name); |
| } |
| } |
| } |
| |
| // Returns true iff the device reports EV_KEY events. |
| bool HasKeyEvents(int device_fd) { |
| unsigned long evbit = 0; |
| // Get the bit field of available event types. |
| ioctl(device_fd, EVIOCGBIT(0, sizeof(evbit)), &evbit); |
| return evbit & (1 << EV_KEY); |
| } |
| |
| // Returns true iff the given device has |key|. |
| bool HasSpecificKey(int device_fd, unsigned int key) { |
| size_t nchar = KEY_MAX/8 + 1; |
| unsigned char bits[nchar]; |
| // Get the bit fields of available keys. |
| ioctl(device_fd, EVIOCGBIT(EV_KEY, sizeof(bits)), &bits); |
| return bits[key/8] & (1 << (key % 8)); |
| } |
| |
| int main(int argc, char** argv) { |
| string input_directory = "/dev/input"; |
| if (argc < 2) { |
| printf("No input directory specified, using the default one: %s.\n", |
| input_directory.c_str()); |
| } else { |
| input_directory = argv[1]; |
| } |
| |
| vector<string> filenames; |
| ListDirectory(input_directory, &filenames); |
| printf("%i devices found in %s.\n", filenames.size(), |
| input_directory.c_str()); |
| |
| // Initializing the pollfd structures. |
| vector<pollfd> poll_fds; |
| char device_name[kMaxDeviceName]; |
| for (size_t i = 0; i < filenames.size(); i++) { |
| int fd = open(filenames[i].c_str(), O_RDONLY); |
| if (fd < 0) { |
| printf("Failed to open %s for reading: %s\n", filenames[i].c_str(), |
| strerror(errno)); |
| return 1; |
| } |
| |
| // Reads the device name. |
| if(ioctl(fd, EVIOCGNAME(sizeof(device_name) - 1), |
| &device_name) < 1) { |
| device_name[0] = '\0'; |
| } |
| |
| if (!HasKeyEvents(fd)) { |
| printf("Discarding %s (%s): does not report any EV_KEY events.\n", |
| filenames[i].c_str(), device_name); |
| continue; |
| } |
| if (!HasSpecificKey(fd, KEY_B)) { |
| printf("Discarding %s (%s): does not have a B key.\n", |
| filenames[i].c_str(), device_name); |
| continue; |
| } |
| poll_fds.push_back(pollfd{fd, POLLIN, 0}); |
| |
| printf("Adding device %s: %s\n", filenames[i].c_str(), device_name); |
| } |
| |
| if (poll_fds.empty()) { |
| printf("No keyboard detected, exiting.\n"); |
| return 1; |
| } |
| |
| // Number of repeated events + 1. |
| int count = 1; |
| // Events accumulated for each device. |
| vector<vector<input_event>> events(poll_fds.size()); |
| |
| const char instructions[] = "Press B to start the game and release B to go " |
| "back to the main menu."; |
| printf("%s\n", instructions); |
| while (true) { |
| // Wait for data to be available on one of the file descriptors without |
| // timeout (-1). |
| poll(poll_fds.data(), poll_fds.size(), -1); |
| |
| for (size_t i = 0; i < poll_fds.size(); i++) { |
| if (poll_fds[i].revents & POLLIN) { |
| struct input_event event; |
| if (read(poll_fds[i].fd, &event, sizeof(event)) != sizeof(event)) { |
| printf("Failed to read an event.\n"); |
| return 1; |
| } |
| |
| // When receiving a key event for B, add it to the list of events. |
| // Don't process it yet as there might be other events in that report. |
| if (event.type == EV_KEY && event.code == KEY_B) { |
| events[i].push_back(event); |
| } |
| |
| // A SYN_REPORT event signals the end of a report, process all the |
| // previously accumulated events. |
| // At that point we only have events for B in the event vector. |
| if (event.type == EV_SYN && event.code == SYN_REPORT) { |
| for (vector<input_event>::iterator it = events[i].begin(); |
| it != events[i].end(); it++) { |
| switch (it->value) { |
| case 0: { |
| // A value of 0 indicates a "key released" event. |
| double percent = 1. - 1./count; |
| printf("%.02f%% loaded.\n", percent * 100); |
| printf("B released, returning to the main menu.\n\n"); |
| printf("%s\n", instructions); |
| break; |
| } |
| case 1: { |
| // A value of 1 indicates a "key pressed" event. |
| printf("B pressed, starting the game...\n"); |
| count = 1; |
| break; |
| } |
| case 2: { |
| // A value of 2 indicates a "key repeat" event. |
| count++; |
| break; |
| } |
| default: {} |
| } |
| } |
| // Discard all processed events. |
| events[i].clear(); |
| } |
| } |
| } |
| } |
| return 0; |
| } |
| |