mbtk/test/others/touch_ev_demo.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <linux/input.h>
#include <unistd.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <time.h>
#include <pthread.h>
#include <sys/poll.h>
#include <dirent.h>
#include <stdbool.h>

// #include "mbtk_log.h"

#ifndef TRUE
#define TRUE   1   /* Boolean true value. */
#endif

#ifndef true
#define true   1   /* Boolean true value. */
#endif

#ifndef FALSE
#define FALSE  0   /* Boolean false value. */
#endif

#ifndef false
#define false  0   /* Boolean false value. */
#endif


#ifndef NULL
#define NULL  0
#endif


#ifndef null
#define null  0
#endif

#define LOGI printf
#define LOGE printf

/**
 * Compiler-digit : 16
 * char : 1     (%c)
 * char* : 2
 * short int : 2
 * int : 2      (%d)
 * unsigned int : 2  (%u)
 * float : 4    (%f)
 * double : 8   (%f)
 * long : 4
 * unsigned long : 4
 * long long : 8
 * unsigned long long : 8
 *
 *
 * Compiler-digit : 32
 * char : 1
 * char* : 4
 * short int : 2
 * int : 4
 * unsigned int : 4
 * float : 4
 * double : 8
 * long : 4
 * unsigned long : 4
 * long long : 8
 * unsigned long long : 8
 *
 *
 * Compiler-digit : 64
 * char : 1
 * char* : 8
 * short int : 2
 * int : 4
 * unsigned int : 4
 * float : 4
 * double : 8
 * long : 8
 * unsigned long : 8
 * long long : 8
 * unsigned long long : 8
 */
typedef unsigned char boolean; /* Boolean value type. */
// typedef unsigned char bool; /* Boolean value type. */
typedef unsigned long long uint64; /* Unsigned 64 bit value */
typedef unsigned long long uint64_t; /* Unsigned 64 bit value */
typedef unsigned int uint32; /* Unsigned 32 bit value */
typedef unsigned int uint32_t; /* Unsigned 32 bit value */
typedef unsigned short uint16; /* Unsigned 16 bit value */
typedef unsigned short uint16_t;
typedef unsigned char uint8; /* Unsigned 8  bit value */
typedef unsigned char uint8_t;
typedef signed long long int64; /* Signed 64 bit value */
typedef signed long long sint64; /* Signed 64 bit value */
typedef signed int int32; /* Signed 32 bit value */
typedef signed int sint32; /* Signed 32 bit value */
typedef signed short int16; /* Signed 16 bit value */
typedef signed short sint16; /* Signed 16 bit value */
typedef signed char int8; /* Signed 8  bit value */
typedef signed char sint8; /* Signed 8  bit value */
typedef unsigned char byte; /* byte type */

//#include "mbtk_type.h"
//#include "mbtk_log.h"

typedef int (*ev_callback)(int fd, uint32_t epevents, void *data);

typedef enum {
    ACTION_DOWN,
    ACTION_MOVE,
    ACTION_UP,
    ACTION_CANCEL
} touch_event_action_enum;

typedef struct {
    touch_event_action_enum action;
    int x;
    int y;
} touch_event;

static int move_x;
static touch_event event_pre;
static bool action_down_get = false;
static bool action_touched = false;

#define MAX_DEVICES 16
#define MAX_MISC_FDS 16

#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 {
    ev_callback cb;
    void *data;
};

static struct pollfd ev_fds[MAX_DEVICES + MAX_MISC_FDS];
static struct fd_info ev_fdinfo[MAX_DEVICES + MAX_MISC_FDS];

static unsigned ev_count = 0;
static unsigned ev_dev_count = 0;
static unsigned ev_misc_count = 0;

int ev_get_input(int fd, short revents, struct input_event *ev);
bool event_process(struct input_event ev);

int ev_cb(int fd, uint32_t epevents, void *data)
{
    struct input_event ev;

    int retval = ev_get_input(fd, epevents, &ev);
    if(retval < 0) return -1;

    if(!event_process(ev)) return 0;

    return 0;
}

int ev_init(void *data)
{
    DIR *dir;
    struct dirent *de;
    int fd;

    dir = opendir("/dev/input");
    if(dir != 0) {
        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;

            /* read the evbits of the input device */
            if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) < 0) {
                close(fd);
                continue;
            }

            /* TODO: add ability to specify event masks. For now, just assume
             * that only EV_KEY and EV_REL event types are ever needed. */
            if (!test_bit(EV_KEY, ev_bits) && !test_bit(EV_REL, ev_bits)) {
                close(fd);
                continue;
            }

            ev_fds[ev_count].fd = fd;
            ev_fds[ev_count].events = POLLIN;
            ev_fdinfo[ev_count].cb = ev_cb;
            ev_fdinfo[ev_count].data = data;
            ev_count++;
            ev_dev_count++;
            if(ev_dev_count == MAX_DEVICES) break;
        }
    }

    return 0;
}

void ev_exit(void)
{
    while (ev_count > 0) {
        close(ev_fds[--ev_count].fd);
    }
    ev_misc_count = 0;
    ev_dev_count = 0;
}

int ev_wait(int timeout)
{
    int r;

    r = poll(ev_fds, ev_count, timeout);
    if (r <= 0)
        return -1;
    return 0;
}

void ev_dispatch(void)
{
    unsigned n;
//    int ret;

    for (n = 0; n < ev_count; n++) {
        ev_callback cb = ev_fdinfo[n].cb;
        if (cb && (ev_fds[n].revents & ev_fds[n].events))
            cb(ev_fds[n].fd, ev_fds[n].revents, ev_fdinfo[n].data);
    }
}

int ev_get_input(int fd, short revents, struct input_event *ev)
{
    int r;

    if (revents & POLLIN) {
        r = read(fd, ev, sizeof(*ev));
        if (r == sizeof(*ev))
            return 0;
    }
    return -1;
}

bool event_process(struct input_event ev)
{
    LOGI("Event:%d,%d,%d\n", ev.type, ev.code, ev.value);

//    if(ev.type != EV_KEY){
//        return false;
//    }

    bool is_touch = true;
    // Touch Down/Up
    if(ev.type == EV_KEY && ev.code == BTN_TOUCH) {
        if(!!ev.value) { // Down
            action_down_get = true;
            action_touched = true;
        }
        else // UP
        {
            action_down_get = false;
            action_touched = false;
        }
    } else if(ev.type == EV_ABS) { // Touch move
        if(!action_touched) // No down
            return false;
    } else if(ev.type != EV_KEY) {
        return false;
    } else {
        is_touch = false;
    }

    if (!is_touch && ev.value < 2){ // 2 is long press events
        int down = !!ev.value;
        if (down){
            LOGI("LongPress : DOWN.");
            //if(!l->onKeyDown(ev.type, ev.code)) return false;
        }else{
            //if(!l->onKeyUp(ev.type, ev.code)) return false;
            LOGI("LongPress : UP.");
        }
    } else if (is_touch) {
        touch_event m_event;
        if(ev.type == EV_ABS) { // Move
            if(ev.code == KEY_SLASH) { // X
                move_x = ev.value;
            } else if(ev.code == KEY_RIGHTSHIFT) { // Y
                if(action_down_get)
                {
                    m_event.action = ACTION_DOWN;
                    action_down_get = false;
                } else {
                    m_event.action = ACTION_MOVE;
                }
                m_event.x = move_x;
                m_event.y = ev.value;

                if(event_pre.x != m_event.x
                    || event_pre.y != m_event.y)
                {
                    event_pre.x = m_event.x;
                    event_pre.y = m_event.y;
                #ifdef MBTK_TP_RESIZE_SUPPORT
                    point_resize(getScreenWidth(),
                        getScreenHeight(),
                        mStatusBar->isVisibility() ? mStatusBar->getHeight() : 0,
                        &m_event);
                #endif
                    LOGI("Window onTouchEvent action:%d (%d,%d) -> (%d,%d)",
                        m_event.action, event_pre.x, event_pre.y, m_event.x, m_event.y);

                }
            } else {
                // Do nothing
            }
        } else if(!action_down_get){ // UP
            m_event.action = ACTION_UP;
            m_event.x = event_pre.x;
            m_event.y = event_pre.y;

        #ifdef MBTK_TP_RESIZE_SUPPORT
            point_resize(getScreenWidth(),
                getScreenHeight(),
                mStatusBar->isVisibility() ? mStatusBar->getHeight() : 0,
                &m_event);
        #endif

            LOGI("Window onTouchEvent action:%d (%d,%d) -> (%d,%d)",
                m_event.action, event_pre.x, event_pre.y, m_event.x, m_event.y);

        } else {
            // Do nothing
        }
    } else {
        // Do nothing
    }

    //invalidate();

    return true;
}

int main(int argc, char *argv[])
{
    // mbtk_log_init(NULL, "MBTK_EVENT");

    if(ev_init(NULL)) {
        LOGE("ev_init() fail.");
        return -1;
    }

    LOGI("event getting...");
    while(1) {
        if(!ev_wait(-1))
            ev_dispatch();
    }

    LOGI("exit!!!");
    return 0;
}