Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0713819f authored by Elliott Hughes's avatar Elliott Hughes
Browse files

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
parent f471861e

minui/Android.mk

+7 −2
Original line number Diff line number Diff line 
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

minui/events.c→minui/events.cpp

+97 −79
Original line number Diff line number Diff line
@@ -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;

};



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) {

    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;

            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;
@@ -101,28 +99,32 @@ int ev_init(ev_callback input_cb, void *data) 
            ev_dev_count++;

            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);

            }

        }

    }

}

minui/minui.h

+22 −13
Original line number Diff line number Diff line
@@ -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 void (*ev_key_callback)(int code, 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);

void ev_iterate_available_keys(ev_key_callback cb, void* data);



/* timeout has the same semantics as for poll

 *    0 : don't block

 *  < 0 : block forever

 *  > 0 : block for 'timeout' milliseconds

 */

// '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.