Add ev_iterate_available_keys to minui.

This lets us recognize whether we have up/down/power, say, and tailor
the UI accordingly.

Change-Id: If94e454f14243b59d2f473ac9a436bd60591da01

3 files changed, 126 insertions, 94 deletions

diff --git a/minui/Android.mk b/minui/Android.mk
index 53d072f..66dea74 100644
--- a/minui/Android.mk
+++ b/minui/Android.mk
@@ -1,14 +1,19 @@
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
-LOCAL_SRC_FILES := graphics.c graphics_adf.c graphics_fbdev.c events.c resources.c
+LOCAL_SRC_FILES := \
+    events.cpp \
+    graphics.c \
+    graphics_adf.c \
+    graphics_fbdev.c \
+    resources.c \
 
 LOCAL_WHOLE_STATIC_LIBRARIES += libadf
 LOCAL_STATIC_LIBRARIES += libpng
 
 LOCAL_MODULE := libminui
 
-LOCAL_CFLAGS := -std=gnu11
+LOCAL_CLANG := true
 
 # This used to compare against values in double-quotes (which are just
 # ordinary characters in this context).  Strip double-quotes from the
diff --git a/minui/events.c b/minui/events.cpp
index 9e4255d..2c41eb8 100644
--- a/minui/events.c
+++ b/minui/events.cpp
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
+#include <dirent.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <dirent.h>
 #include <sys/epoll.h>
+#include <unistd.h>
 
 #include <linux/input.h>
 
@@ -32,16 +32,13 @@
 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
 #define BITS_TO_LONGS(x) (((x) + BITS_PER_LONG - 1) / BITS_PER_LONG)
 
-#define test_bit(bit, array) \
-    ((array)[(bit)/BITS_PER_LONG] & (1 << ((bit) % BITS_PER_LONG)))
-
 struct fd_info {
     int fd;
     ev_callback cb;
-    void *data;
+    void* data;
 };
 
-static int epollfd;
+static int g_epoll_fd;
 static struct epoll_event polledevents[MAX_DEVICES + MAX_MISC_FDS];
 static int npolledevents;
 
@@ -51,44 +48,45 @@ static unsigned ev_count = 0;
 static unsigned ev_dev_count = 0;
 static unsigned ev_misc_count = 0;
 
-int ev_init(ev_callback input_cb, void *data)
-{
-    DIR *dir;
-    struct dirent *de;
-    int fd;
-    struct epoll_event ev;
+static bool test_bit(size_t bit, unsigned long* array) {
+    return (array[bit/BITS_PER_LONG] & (1UL << (bit % BITS_PER_LONG))) != 0;
+}
+
+int ev_init(ev_callback input_cb, void* data) {
     bool epollctlfail = false;
 
-    epollfd = epoll_create(MAX_DEVICES + MAX_MISC_FDS);
-    if (epollfd == -1)
+    g_epoll_fd = epoll_create(MAX_DEVICES + MAX_MISC_FDS);
+    if (g_epoll_fd == -1) {
         return -1;
+    }
 
-    dir = opendir("/dev/input");
-    if(dir != 0) {
-        while((de = readdir(dir))) {
+    DIR* dir = opendir("/dev/input");
+    if (dir != NULL) {
+        struct dirent* de;
+        while ((de = readdir(dir))) {
             unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];
 
 //            fprintf(stderr,"/dev/input/%s\n", de->d_name);
-            if(strncmp(de->d_name,"event",5)) continue;
-            fd = openat(dirfd(dir), de->d_name, O_RDONLY);
-            if(fd < 0) continue;
+            if (strncmp(de->d_name, "event", 5)) continue;
+            int fd = openat(dirfd(dir), de->d_name, O_RDONLY);
+            if (fd == -1) continue;
 
-            /* read the evbits of the input device */
-            if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) < 0) {
+            // Read the evbits of the input device.
+            if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
                 close(fd);
                 continue;
             }
 
-            /* TODO: add ability to specify event masks. For now, just assume
-             * that only EV_KEY, EV_REL & EV_SW event types are ever needed. */
+            // We assume that only EV_KEY, EV_REL, and EV_SW event types are ever needed.
             if (!test_bit(EV_KEY, ev_bits) && !test_bit(EV_REL, ev_bits) && !test_bit(EV_SW, ev_bits)) {
                 close(fd);
                 continue;
             }
 
+            struct epoll_event ev;
             ev.events = EPOLLIN | EPOLLWAKEUP;
-            ev.data.ptr = (void *)&ev_fdinfo[ev_count];
-            if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev)) {
+            ev.data.ptr = &ev_fdinfo[ev_count];
+            if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
                 close(fd);
                 epollctlfail = true;
                 continue;
@@ -99,30 +97,34 @@ int ev_init(ev_callback input_cb, void *data)
             ev_fdinfo[ev_count].data = data;
             ev_count++;
             ev_dev_count++;
-            if(ev_dev_count == MAX_DEVICES) break;
+            if (ev_dev_count == MAX_DEVICES) break;
         }
+
+        closedir(dir);
     }
 
     if (epollctlfail && !ev_count) {
-        close(epollfd);
-        epollfd = -1;
+        close(g_epoll_fd);
+        g_epoll_fd = -1;
         return -1;
     }
 
     return 0;
 }
 
-int ev_add_fd(int fd, ev_callback cb, void *data)
-{
-    struct epoll_event ev;
-    int ret;
+int ev_get_epollfd(void) {
+    return g_epoll_fd;
+}
 
-    if (ev_misc_count == MAX_MISC_FDS || cb == NULL)
+int ev_add_fd(int fd, ev_callback cb, void* data) {
+    if (ev_misc_count == MAX_MISC_FDS || cb == NULL) {
         return -1;
+    }
 
+    struct epoll_event ev;
     ev.events = EPOLLIN | EPOLLWAKEUP;
     ev.data.ptr = (void *)&ev_fdinfo[ev_count];
-    ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
+    int ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev);
     if (!ret) {
         ev_fdinfo[ev_count].fd = fd;
         ev_fdinfo[ev_count].cb = cb;
@@ -134,80 +136,96 @@ int ev_add_fd(int fd, ev_callback cb, void *data)
     return ret;
 }
 
-int ev_get_epollfd(void)
-{
-    return epollfd;
-}
-
-void ev_exit(void)
-{
+void ev_exit(void) {
     while (ev_count > 0) {
         close(ev_fdinfo[--ev_count].fd);
     }
     ev_misc_count = 0;
     ev_dev_count = 0;
-    close(epollfd);
+    close(g_epoll_fd);
 }
 
-int ev_wait(int timeout)
-{
-    npolledevents = epoll_wait(epollfd, polledevents, ev_count, timeout);
-    if (npolledevents <= 0)
+int ev_wait(int timeout) {
+    npolledevents = epoll_wait(g_epoll_fd, polledevents, ev_count, timeout);
+    if (npolledevents <= 0) {
         return -1;
+    }
     return 0;
 }
 
-void ev_dispatch(void)
-{
-    int n;
-    int ret;
-
-    for (n = 0; n < npolledevents; n++) {
-        struct fd_info *fdi = polledevents[n].data.ptr;
+void ev_dispatch(void) {
+    for (int n = 0; n < npolledevents; n++) {
+        fd_info* fdi = reinterpret_cast<fd_info*>(polledevents[n].data.ptr);
         ev_callback cb = fdi->cb;
-        if (cb)
+        if (cb) {
             cb(fdi->fd, polledevents[n].events, fdi->data);
+        }
     }
 }
 
-int ev_get_input(int fd, uint32_t epevents, struct input_event *ev)
-{
-    int r;
-
+int ev_get_input(int fd, uint32_t epevents, struct input_event* ev) {
     if (epevents & EPOLLIN) {
-        r = read(fd, ev, sizeof(*ev));
-        if (r == sizeof(*ev))
+        ssize_t r = read(fd, ev, sizeof(*ev));
+        if (r == sizeof(*ev)) {
             return 0;
+        }
     }
     return -1;
 }
 
-int ev_sync_key_state(ev_set_key_callback set_key_cb, void *data)
-{
-    unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)];
+int ev_sync_key_state(ev_set_key_callback set_key_cb, void* data) {
     unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];
-    unsigned i;
-    int ret;
-
-    for (i = 0; i < ev_dev_count; i++) {
-        int code;
+    unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)];
 
-        memset(key_bits, 0, sizeof(key_bits));
+    for (size_t i = 0; i < ev_dev_count; ++i) {
         memset(ev_bits, 0, sizeof(ev_bits));
+        memset(key_bits, 0, sizeof(key_bits));
 
-        ret = ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
-        if (ret < 0 || !test_bit(EV_KEY, ev_bits))
+        if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
             continue;
-
-        ret = ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits);
-        if (ret < 0)
+        }
+        if (!test_bit(EV_KEY, ev_bits)) {
             continue;
+        }
+        if (ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits) == -1) {
+            continue;
+        }
 
-        for (code = 0; code <= KEY_MAX; code++) {
-            if (test_bit(code, key_bits))
+        for (int code = 0; code <= KEY_MAX; code++) {
+            if (test_bit(code, key_bits)) {
                 set_key_cb(code, 1, data);
+            }
         }
     }
 
     return 0;
 }
+
+void ev_iterate_available_keys(ev_key_callback cb, void* data) {
+    unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];
+    unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)];
+
+    for (size_t i = 0; i < ev_dev_count; ++i) {
+        memset(ev_bits, 0, sizeof(ev_bits));
+        memset(key_bits, 0, sizeof(key_bits));
+
+        // Does this device even have keys?
+        if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
+            continue;
+        }
+        if (!test_bit(EV_KEY, ev_bits)) {
+            continue;
+        }
+
+        int rc = ioctl(ev_fdinfo[i].fd, EVIOCGBIT(EV_KEY, KEY_MAX), key_bits);
+        if (rc == -1) {
+            continue;
+        }
+
+        for (int key_code = 0; key_code <= KEY_MAX; ++key_code) {
+            if (test_bit(key_code, key_bits)) {
+                cb(key_code, data);
+            }
+        }
+    }
+}
diff --git a/minui/minui.h b/minui/minui.h
index 733b675..8f2ff11 100644
--- a/minui/minui.h
+++ b/minui/minui.h
@@ -25,6 +25,10 @@
 extern "C" {
 #endif
 
+//
+// Graphics.
+//
+
 typedef struct {
     int width;
     int height;
@@ -56,30 +60,35 @@ void gr_blit(gr_surface source, int sx, int sy, int w, int h, int dx, int dy);
 unsigned int gr_get_width(gr_surface surface);
 unsigned int gr_get_height(gr_surface surface);
 
-// input event structure, include <linux/input.h> for the definition.
-// see http://www.mjmwired.net/kernel/Documentation/input/ for info.
+//
+// Input events.
+//
+
 struct input_event;
 
-typedef int (*ev_callback)(int fd, uint32_t epevents, void *data);
-typedef int (*ev_set_key_callback)(int code, int value, void *data);
+typedef int (*ev_callback)(int fd, uint32_t epevents, void* data);
+typedef int (*ev_set_key_callback)(int code, int value, void* data);
+typedef void (*ev_key_callback)(int code, void* data);
 
-int ev_init(ev_callback input_cb, void *data);
+int ev_init(ev_callback input_cb, void* data);
 void ev_exit(void);
-int ev_add_fd(int fd, ev_callback cb, void *data);
-int ev_sync_key_state(ev_set_key_callback set_key_cb, void *data);
-
-/* timeout has the same semantics as for poll
- *    0 : don't block
- *  < 0 : block forever
- *  > 0 : block for 'timeout' milliseconds
- */
+int ev_add_fd(int fd, ev_callback cb, void* data);
+int ev_sync_key_state(ev_set_key_callback set_key_cb, void* data);
+void ev_iterate_available_keys(ev_key_callback cb, void* data);
+
+// 'timeout' has the same semantics as poll(2).
+//    0 : don't block
+//  < 0 : block forever
+//  > 0 : block for 'timeout' milliseconds
 int ev_wait(int timeout);
 
 int ev_get_input(int fd, uint32_t epevents, struct input_event *ev);
 void ev_dispatch(void);
 int ev_get_epollfd(void);
 
+//
 // Resources
+//
 
 // res_create_*_surface() functions return 0 if no error, else
 // negative.