Merge "minui: Move callback functions to std::function." am: a476312714 am: 343987b2a1

am: 19856bcb2e

Change-Id: Ifed7e368ce476adac7361b2480091693e2446898

minui/events.cpp

@@ -15,16 +15,14 @@
  */
 
 #include <dirent.h>
-#include <errno.h>
+#include <linux/input.h>
-#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/epoll.h>
+#include <sys/ioctl.h>
 #include <unistd.h>
 
-#include <linux/input.h>
-
 #include "minui/minui.h"
 
 #define MAX_DEVICES 16
@@ -34,9 +32,8 @@
 #define BITS_TO_LONGS(x) (((x) + BITS_PER_LONG - 1) / BITS_PER_LONG)
 
 struct fd_info {
-    int fd;
+  int fd;
-    ev_callback cb;
+  ev_callback cb;
-    void* data;
 };
 
 static int g_epoll_fd;
@@ -53,89 +50,87 @@ static bool test_bit(size_t bit, unsigned long* array) { // NOLINT
     return (array[bit/BITS_PER_LONG] & (1UL << (bit % BITS_PER_LONG))) != 0;
 }
 
-int ev_init(ev_callback input_cb, void* data) {
+int ev_init(ev_callback input_cb) {
-    bool epollctlfail = false;
+  bool epollctlfail = false;
 
-    g_epoll_fd = epoll_create(MAX_DEVICES + MAX_MISC_FDS);
+  g_epoll_fd = epoll_create(MAX_DEVICES + MAX_MISC_FDS);
-    if (g_epoll_fd == -1) {
+  if (g_epoll_fd == -1) {
-        return -1;
+    return -1;
+  }
+
+  DIR* dir = opendir("/dev/input");
+  if (dir != NULL) {
+    dirent* de;
+    while ((de = readdir(dir))) {
+      // Use unsigned long to match ioctl's parameter type.
+      unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];  // NOLINT
+
+      //            fprintf(stderr,"/dev/input/%s\n", de->d_name);
+      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) == -1) {
+        close(fd);
+        continue;
+      }
+
+      // 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;
+      }
+
+      epoll_event ev;
+      ev.events = EPOLLIN | EPOLLWAKEUP;
+      ev.data.ptr = &ev_fdinfo[ev_count];
+      if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
+        close(fd);
+        epollctlfail = true;
+        continue;
+      }
+
+      ev_fdinfo[ev_count].fd = fd;
+      ev_fdinfo[ev_count].cb = std::move(input_cb);
+      ev_count++;
+      ev_dev_count++;
+      if (ev_dev_count == MAX_DEVICES) break;
     }
 
-    DIR* dir = opendir("/dev/input");
+    closedir(dir);
-    if (dir != NULL) {
+  }
-        dirent* de;
-        while ((de = readdir(dir))) {
-            // Use unsigned long to match ioctl's parameter type.
-            unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)]; // NOLINT
 
-//            fprintf(stderr,"/dev/input/%s\n", de->d_name);
+  if (epollctlfail && !ev_count) {
-            if (strncmp(de->d_name, "event", 5)) continue;
+    close(g_epoll_fd);
-            int fd = openat(dirfd(dir), de->d_name, O_RDONLY);
+    g_epoll_fd = -1;
-            if (fd == -1) continue;
+    return -1;
+  }
 
-            // Read the evbits of the input device.
+  return 0;
-            if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
-                close(fd);
-                continue;
-            }
-
-            // 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;
-            }
-
-            epoll_event ev;
-            ev.events = EPOLLIN | EPOLLWAKEUP;
-            ev.data.ptr = &ev_fdinfo[ev_count];
-            if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
-                close(fd);
-                epollctlfail = true;
-                continue;
-            }
-
-            ev_fdinfo[ev_count].fd = fd;
-            ev_fdinfo[ev_count].cb = input_cb;
-            ev_fdinfo[ev_count].data = data;
-            ev_count++;
-            ev_dev_count++;
-            if (ev_dev_count == MAX_DEVICES) break;
-        }
-
-        closedir(dir);
-    }
-
-    if (epollctlfail && !ev_count) {
-        close(g_epoll_fd);
-        g_epoll_fd = -1;
-        return -1;
-    }
-
-    return 0;
 }
 
 int ev_get_epollfd(void) {
     return g_epoll_fd;
 }
 
-int ev_add_fd(int fd, ev_callback cb, void* data) {
+int ev_add_fd(int fd, ev_callback cb) {
-    if (ev_misc_count == MAX_MISC_FDS || cb == NULL) {
+  if (ev_misc_count == MAX_MISC_FDS || cb == NULL) {
-        return -1;
+    return -1;
-    }
+  }
 
-    epoll_event ev;
+  epoll_event ev;
-    ev.events = EPOLLIN | EPOLLWAKEUP;
+  ev.events = EPOLLIN | EPOLLWAKEUP;
-    ev.data.ptr = (void *)&ev_fdinfo[ev_count];
+  ev.data.ptr = static_cast<void*>(&ev_fdinfo[ev_count]);
-    int ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev);
+  int ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &ev);
-    if (!ret) {
+  if (!ret) {
-        ev_fdinfo[ev_count].fd = fd;
+    ev_fdinfo[ev_count].fd = fd;
-        ev_fdinfo[ev_count].cb = cb;
+    ev_fdinfo[ev_count].cb = std::move(cb);
-        ev_fdinfo[ev_count].data = data;
+    ev_count++;
-        ev_count++;
+    ev_misc_count++;
-        ev_misc_count++;
+  }
-    }
 
-    return ret;
+  return ret;
 }
 
 void ev_exit(void) {
@@ -156,13 +151,13 @@ int ev_wait(int timeout) {
 }
 
 void ev_dispatch(void) {
-    for (int n = 0; n < npolledevents; n++) {
+  for (int n = 0; n < npolledevents; n++) {
-        fd_info* fdi = reinterpret_cast<fd_info*>(polledevents[n].data.ptr);
+    fd_info* fdi = static_cast<fd_info*>(polledevents[n].data.ptr);
-        ev_callback cb = fdi->cb;
+    const ev_callback& cb = fdi->cb;
-        if (cb) {
+    if (cb) {
-            cb(fdi->fd, polledevents[n].events, fdi->data);
+      cb(fdi->fd, polledevents[n].events);
-        }
     }
+  }
 }
 
 int ev_get_input(int fd, uint32_t epevents, input_event* ev) {
@@ -175,33 +170,33 @@ int ev_get_input(int fd, uint32_t epevents, input_event* ev) {
     return -1;
 }
 
-int ev_sync_key_state(ev_set_key_callback set_key_cb, void* data) {
+int ev_sync_key_state(const ev_set_key_callback& set_key_cb) {
-    // Use unsigned long to match ioctl's parameter type.
+  // Use unsigned long to match ioctl's parameter type.
-    unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)]; // NOLINT
+  unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];    // NOLINT
-    unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)]; // NOLINT
+  unsigned long key_bits[BITS_TO_LONGS(KEY_MAX)];  // NOLINT
 
-    for (size_t i = 0; i < ev_dev_count; ++i) {
+  for (size_t i = 0; i < ev_dev_count; ++i) {
-        memset(ev_bits, 0, sizeof(ev_bits));
+    memset(ev_bits, 0, sizeof(ev_bits));
-        memset(key_bits, 0, sizeof(key_bits));
+    memset(key_bits, 0, sizeof(key_bits));
 
-        if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
+    if (ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1) {
-            continue;
+      continue;
-        }
+    }
-        if (!test_bit(EV_KEY, ev_bits)) {
+    if (!test_bit(EV_KEY, ev_bits)) {
-            continue;
+      continue;
-        }
+    }
-        if (ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits) == -1) {
+    if (ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits) == -1) {
-            continue;
+      continue;
-        }
-
-        for (int code = 0; code <= KEY_MAX; code++) {
-            if (test_bit(code, key_bits)) {
-                set_key_cb(code, 1, data);
-            }
-        }
     }
 
-    return 0;
+    for (int code = 0; code <= KEY_MAX; code++) {
+      if (test_bit(code, key_bits)) {
+        set_key_cb(code, 1);
+      }
+    }
+  }
+
+  return 0;
 }
 
 void ev_iterate_available_keys(const std::function<void(int)>& f) {

minui/include/minui/minui.h

@@ -70,15 +70,14 @@ unsigned int gr_get_height(GRSurface* surface);
 
 struct input_event;
 
-// TODO: move these over to std::function.
+using ev_callback = std::function<int(int fd, uint32_t epevents)>;
-typedef int (*ev_callback)(int fd, uint32_t epevents, void* data);
+using ev_set_key_callback = std::function<int(int code, int value)>;
-typedef int (*ev_set_key_callback)(int code, int value, void* data);
 
-int ev_init(ev_callback input_cb, void* data);
+int ev_init(ev_callback input_cb);
 void ev_exit();
-int ev_add_fd(int fd, ev_callback cb, void* data);
+int ev_add_fd(int fd, ev_callback cb);
 void ev_iterate_available_keys(const std::function<void(int)>& f);
-int ev_sync_key_state(ev_set_key_callback set_key_cb, void* data);
+int ev_sync_key_state(const ev_set_key_callback& set_key_cb);
 
 // 'timeout' has the same semantics as poll(2).
 //    0 : don't block

minui/resources.cpp

@@ -14,21 +14,19 @@
  * limitations under the License.
  */
 
+#include <fcntl.h>
+#include <linux/fb.h>
+#include <linux/kd.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-
-#include <fcntl.h>
-#include <stdio.h>
-
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/types.h>
-
+#include <unistd.h>
-#include <linux/fb.h>
-#include <linux/kd.h>
 
 #include <vector>
+
 #include <png.h>
 
 #include "minui/minui.h"

ui.cpp

@@ -34,11 +34,11 @@
 
 #include <android-base/properties.h>
 #include <cutils/android_reboot.h>
+#include <minui/minui.h>
 
 #include "common.h"
 #include "roots.h"
 #include "device.h"
-#include "minui/minui.h"
 
 #define UI_WAIT_KEY_TIMEOUT_SEC    120
 
@@ -70,10 +70,6 @@ void RecoveryUI::OnKeyDetected(int key_code) {
     }
 }
 
-int RecoveryUI::InputCallback(int fd, uint32_t epevents, void* data) {
-    return reinterpret_cast<RecoveryUI*>(data)->OnInputEvent(fd, epevents);
-}
-
 // Reads input events, handles special hot keys, and adds to the key queue.
 static void* InputThreadLoop(void*) {
     while (true) {
@@ -88,7 +84,7 @@ bool RecoveryUI::Init(const std::string& locale) {
   // Set up the locale info.
   SetLocale(locale);
 
-  ev_init(InputCallback, this);
+  ev_init(std::bind(&RecoveryUI::OnInputEvent, this, std::placeholders::_1, std::placeholders::_2));
 
   ev_iterate_available_keys(std::bind(&RecoveryUI::OnKeyDetected, this, std::placeholders::_1));
 

ui.h

@@ -158,8 +158,6 @@ class RecoveryUI {
     pthread_t input_thread_;
 
     void OnKeyDetected(int key_code);
-
-    static int InputCallback(int fd, uint32_t epevents, void* data);
     int OnInputEvent(int fd, uint32_t epevents);
     void ProcessKey(int key_code, int updown);