static int input_callback(int fd, short revents, void *data)
{
struct input_event ev;
int ret;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
pr_verbose("Event type: %x, code: %x, value: %x\n",
ev.type, ev.code,
ev.value);
/* ignore key press when provisioning */
if (ignore_keypress)
return 0;
/*
* press power to boot selected kernel immediately
* press other keys to cancel boot
*/
if (autoboot_enabled && ev.type == EV_KEY) {
if (ev.code == KEY_POWER)
power_pressed = 1;
else
disable_autoboot();
return 0;
}
/*
* handle VOLUMEUP, VOLUMEDOWN, POWER press event for rendering menu
* and we don't care repeat key event (ev.value == 2)
*/
if (ev.type == EV_KEY && ev.value == 1) {
if (ev.code == KEY_VOLUMEUP || ev.code == KEY_VOLUMEDOWN ||
ev.code == KEY_POWER) {
RESET_ALARM;
if (lcd_state != lcd_state_on) {
/* do and only do light on LCD */
lcd_state = (lcd_state_t)lcd_state(LCD_KEY);
return 0;
}
}
if (ev.code == KEY_VOLUMEUP)
tboot_ui_menu_up();
else if (ev.code == KEY_VOLUMEDOWN)
tboot_ui_menu_down();
else if (ev.code == KEY_POWER)
tboot_ui_menu_action();
else
pr_debug("unkown key pressed.\n");
}
return 0;
}
int input_callback(int fd, short revents, void*data)
{
struct input_event ev;
int ret;
ret = ev_get_input(fd, revents, &ev);//读取输入消息
if(ret)
return -1;
if (ev.type == 3)
process_touch(ev.code, ev.value);
return 0;
}
/**
* Defined case run in mmi mode,this mode support UI.
* @return, 0 -success; -1
*/
static int key_input_callback(int fd, uint32_t revents, void *data) {
struct input_event ev;
char tmp[SIZE_512] = { 0 };
char buf[SIZE_512] = { 0 };
int retval = 0;
unsigned int i = 0;
retval = ev_get_input(fd, revents, &ev);
if(retval < 0)
return -1;
if(ev.type == EV_KEY) {
for(i = 0; i < (sizeof(key_map) / sizeof(key_map_t)); i++) {
if((ev.code == key_map[i].key_code) && (ev.value == 0)) {
key_map[i].tested = true;
}
}
}
for(i = 0; i < (sizeof(key_map) / sizeof(key_map_t)); i++) {
if((key_map[i].exist) && (key_map[i].tested))
pcba_success = true;
else if((key_map[i].exist) && !(key_map[i].tested)) {
pcba_success = false;
break;
}
}
if(pcba_success) {
for(i = 0; i < (sizeof(key_map) / sizeof(key_map_t)); i++) {
if(key_map[i].exist && key_map[i].tested) {
snprintf(buf, sizeof(buf), "%s = detected\n", key_map[i].key_name);
strncat(tmp, buf, sizeof(buf));
}
}
snprintf(buf, sizeof(buf), "Key PCBA test Pass\n%s", tmp);
g_module->cb_print(module_name, SUBCMD_PCBA, buf, strlen(buf), PRINT_DATA);
sem_post(&semaphore_key_success);
} else if((ev.type == EV_KEY) && (ev.value == 0)) {
for(i = 0; i < (sizeof(key_map) / sizeof(key_map_t)); i++) {
if(key_map[i].exist && key_map[i].tested) {
snprintf(buf, sizeof(buf), "%s = detected\n", key_map[i].key_name);
strncat(tmp, buf, sizeof(buf));
} else if(key_map[i].exist && !key_map[i].tested) {
snprintf(buf, sizeof(buf), "%s = not detected\n", key_map[i].key_name);
strncat(tmp, buf, sizeof(buf));
}
}
snprintf(buf, sizeof(buf), "Key PCBA test Fail\n%s", tmp);
g_module->cb_print(module_name, SUBCMD_PCBA, buf, strlen(buf), PRINT_DATA);
}
return 0;
}
static int input_cb(int fd, unsigned int epevents, void *data)
{
struct input_event ev;
int *key_code = (int *)data;
*key_code = -1;
if (ev_get_input(fd, epevents, &ev)) {
return -1;
}
if (ev.type == EV_KEY && ev.value == 1) {
*key_code = ev.code;
}
return 0;
}
int RecoveryUI::input_callback(int fd, short revents, void* data)
{
struct input_event ev;
int ret;
//self->Print("input_callback CALL \n");
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
#ifdef BOARD_TOUCH_RECOVERY
if(self->touch_handle_input(ev))
return 0;
#endif
if (ev.type == EV_SYN) {
return 0;
} else if (ev.type == EV_REL) {
if (ev.code == REL_Y) {
// accumulate the up or down motion reported by
// the trackball. When it exceeds a threshold
// (positive or negative), fake an up/down
// key event.
self->rel_sum += ev.value;
if (self->rel_sum > 3) {
self->process_key(KEY_DOWN, 1); // press down key
self->process_key(KEY_DOWN, 0); // and release it
self->rel_sum = 0;
} else if (self->rel_sum < -3) {
self->process_key(KEY_UP, 1); // press up key
self->process_key(KEY_UP, 0); // and release it
self->rel_sum = 0;
}
}
} else {
self->rel_sum = 0;
}
if (ev.type == EV_KEY && ev.code <= KEY_MAX)
self->process_key(ev.code, ev.value);
return 0;
}
static int input_callback(int fd, short revents, void *data)
{
struct input_event ev;
int ret;
int fake_key = 0;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
#ifdef BOARD_TOUCH_RECOVERY
if (touch_handle_input(fd, ev))
return 0;
#endif
if (ev.type == EV_SYN) {
return 0;
} else if (ev.type == EV_REL) {
if (ev.code == REL_Y) {
// accumulate the up or down motion reported by
// the trackball. When it exceeds a threshold
// (positive or negative), fake an up/down
// key event.
rel_sum += ev.value;
if (rel_sum > 3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_DOWN;
ev.value = 1;
rel_sum = 0;
} else if (rel_sum < -3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_UP;
ev.value = 1;
rel_sum = 0;
}
}
} else {
rel_sum = 0;
}
if (ev.type != EV_KEY || ev.code > KEY_MAX)
return 0;
if (ev.value == 2) {
boardEnableKeyRepeat = 0;
}
pthread_mutex_lock(&key_queue_mutex);
if (!fake_key) {
// our "fake" keys only report a key-down event (no
// key-up), so don't record them in the key_pressed
// table.
key_pressed[ev.code] = ev.value;
}
const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);
if (ev.value > 0 && key_queue_len < queue_max) {
key_queue[key_queue_len++] = ev.code;
if (boardEnableKeyRepeat) {
struct timeval now;
gettimeofday(&now, NULL);
key_press_time[ev.code] = (now.tv_sec * 1000) + (now.tv_usec / 1000);
key_last_repeat[ev.code] = 0;
}
pthread_cond_signal(&key_queue_cond);
}
pthread_mutex_unlock(&key_queue_mutex);
if (ev.value > 0 && device_toggle_display(key_pressed, ev.code)) {
pthread_mutex_lock(&gUpdateMutex);
show_text = !show_text;
if (show_text) show_text_ever = 1;
update_screen_locked();
pthread_mutex_unlock(&gUpdateMutex);
}
if (ev.value > 0 && device_reboot_now(key_pressed, ev.code)) {
android_reboot(ANDROID_RB_RESTART, 0, 0);
}
return 0;
}
static int input_callback(int fd, short revents, void *data)
{
struct input_event ev;
int ret;
int fake_key = 0;
gr_surface surface = gVirtualKeys;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
#ifdef BOARD_TOUCH_RECOVERY
if (touch_handle_input(fd, ev))
return 0;
#endif
if (ev.type == EV_SYN) {
return 0;
} else if (ev.type == EV_REL) {
if (ev.code == REL_Y) {
// accumulate the up or down motion reported by
// the trackball. When it exceeds a threshold
// (positive or negative), fake an up/down
// key event.
rel_sum += ev.value;
if (rel_sum > 3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_DOWN;
ev.value = 1;
rel_sum = 0;
} else if (rel_sum < -3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_UP;
ev.value = 1;
rel_sum = 0;
}
}
} else {
rel_sum = 0;
}
if (ev.type == 3 && ev.code == 48 && ev.value != 0) {
if (in_touch == 0) {
in_touch = 1; //starting to track touch...
reset_gestures();
}
} else if (ev.type == 3 && ev.code == 48 && ev.value == 0) {
//finger lifted! lets run with this
ev.type = EV_KEY; //touch panel support!!!
int keywidth = gr_get_width(surface) / 4;
int keyoffset = (gr_fb_width() - gr_get_width(surface)) / 2;
if (touch_y > (gr_fb_height() - gr_get_height(surface)) && touch_x > 0) {
//they lifted in the touch panel region
if (touch_x < (keywidth + keyoffset)) {
//down button
ev.code = KEY_DOWN;
reset_gestures();
} else if (touch_x < ((keywidth * 2) + keyoffset)) {
//up button
ev.code = KEY_UP;
reset_gestures();
} else if (touch_x < ((keywidth * 3) + keyoffset)) {
//back button
ev.code = KEY_BACK;
reset_gestures();
} else {
//enter key
ev.code = KEY_ENTER;
reset_gestures();
}
vibrate(VIBRATOR_TIME_MS);
}
if (slide_right == 1) {
ev.code = KEY_ENTER;
slide_right = 0;
} else if (slide_left == 1) {
ev.code = KEY_BACK;
slide_left = 0;
}
ev.value = 1;
in_touch = 0;
reset_gestures();
} else if (ev.type == 3 && ev.code == 53) {
old_x = touch_x;
touch_x = ev.value;
if (old_x != 0)
diff_x += touch_x - old_x;
if (touch_y < (gr_fb_height() - gr_get_height(surface))) {
if (diff_x > (gr_fb_width() / 4)) {
slide_right = 1;
reset_gestures();
} else if(diff_x < ((gr_fb_width() / 4) * -1)) {
slide_left = 1;
reset_gestures();
}
} else {
input_buttons();
//reset_gestures();
}
} else if (ev.type == 3 && ev.code == 54) {
old_y = touch_y;
touch_y = ev.value;
if (old_y != 0)
diff_y += touch_y - old_y;
if (touch_y < (gr_fb_height() - gr_get_height(surface))) {
if (diff_y > 25) {
ev.code = KEY_DOWN;
ev.type = EV_KEY;
reset_gestures();
} else if (diff_y < -25) {
ev.code = KEY_UP;
ev.type = EV_KEY;
reset_gestures();
}
} else {
input_buttons();
//reset_gestures();
}
}
if (ev.type != EV_KEY || ev.code > KEY_MAX)
return 0;
pthread_mutex_lock(&key_queue_mutex);
if (!fake_key) {
// our "fake" keys only report a key-down event (no
// key-up), so don't record them in the key_pressed
// table.
key_pressed[ev.code] = ev.value;
}
const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);
if (ev.value > 0 && key_queue_len < queue_max) {
key_queue[key_queue_len++] = ev.code;
if (boardEnableKeyRepeat) {
struct timeval now;
gettimeofday(&now, NULL);
key_press_time[ev.code] = (now.tv_sec * 1000) + (now.tv_usec / 1000);
key_last_repeat[ev.code] = 0;
}
pthread_cond_signal(&key_queue_cond);
}
pthread_mutex_unlock(&key_queue_mutex);
if (ev.value > 0 && device_toggle_display(key_pressed, ev.code)) {
pthread_mutex_lock(&gUpdateMutex);
show_text = !show_text;
if (show_text) show_text_ever = 1;
update_screen_locked();
pthread_mutex_unlock(&gUpdateMutex);
}
if (ev.value > 0 && device_reboot_now(key_pressed, ev.code)) {
android_reboot(ANDROID_RB_RESTART, 0, 0);
}
return 0;
}
static int input_callback(int fd, short revents, void *data)
{
struct input_event ev;
int rel_sum_x = 0;
int rel_sum_y = 0;
int ret;
int fake_key = 0;
int got_data = 0;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
if (ev.type == EV_SYN) {
// end of a multitouch point
if (ev.code == SYN_MT_REPORT) {
if (touchY > 0 && actPos.y < touchY) {
actPos.num = 0;
actPos.x = 0;
actPos.y = 0;
actPos.pressure = 0;
actPos.size = 0;
}
if (actPos.num>=0 && actPos.num<MAX_MT_POINTS) {
// create a fake keyboard event. We will use BTN_WHEEL, BTN_GEAR_DOWN and BTN_GEAR_UP key events to fake
// TOUCH_MOVE, TOUCH_DOWN and TOUCH_UP in this order
int type = BTN_WHEEL;
// new and old pressure state are not consistent --> we have touch down or up event
if ((mousePos[actPos.num].pressure!=0) != (actPos.pressure!=0)) {
if (actPos.pressure == 0) {
type = BTN_GEAR_UP;
if (actPos.num==0) {
if (mousePos[0].length<15) {
// consider this a mouse click
type = BTN_MOUSE;
}
memset(&grabPos,0,sizeof(grabPos));
}
} else if (actPos.pressure != 0) {
type == BTN_GEAR_DOWN;
if (actPos.num==0) {
grabPos = actPos;
}
}
}
fake_key = 1;
ev.type = EV_KEY;
ev.code = type;
ev.value = actPos.num+1;
// this should be locked, but that causes ui events to get dropped, as the screen drawing takes too much time
// this should be solved by making the critical section inside the drawing much much smaller
if (actPos.pressure) {
if (mousePos[actPos.num].pressure) {
actPos.length = mousePos[actPos.num].length + abs(mousePos[actPos.num].x-actPos.x) + abs(mousePos[actPos.num].y-actPos.y);
} else {
actPos.length = 0;
}
} else {
actPos.length = 0;
}
oldMousePos[actPos.num] = mousePos[actPos.num];
mousePos[actPos.num] = actPos;
int curPos[] = {actPos.pressure, actPos.x, actPos.y};
ui_handle_mouse_input(curPos);
}
memset(&actPos,0,sizeof(actPos));
} else {
return 0;
}
} else if (ev.type == EV_ABS) {
// multitouch records are sent as ABS events. Well at least on the SGS-i9000
if (ev.code == ABS_MT_POSITION_X) {
actPos.x = MT_X(ev.value);
} else if (ev.code == ABS_MT_POSITION_Y) {
actPos.y = MT_Y(ev.value);
if (touchY > 0 && actPos.y < touchY) { actPos.y = 0; }
} else if (ev.code == ABS_MT_TOUCH_MAJOR) {
actPos.pressure = ev.value; // on SGS-i9000 this is 0 for not-pressed and 40 for pressed
} else if (ev.code == ABS_MT_WIDTH_MAJOR) {
// num is stored inside the high byte of width. Well at least on SGS-i9000
if (actPos.num==0) {
// only update if it was not already set. On a normal device MT_TRACKING_ID is sent
actPos.num = ev.value >> 8;
}
actPos.size = ev.value & 0xFF;
} else if (ev.code == ABS_MT_TRACKING_ID) {
static int input_callback(int fd, short revents, void *data) {
struct input_event ev;
int ret;
int fake_key = 0;
ret = ev_get_input(fd, revents, &ev);
if (ret)
return -1;
input_device dev;
dev.fd = fd;
if(!dev.touch_calibrated)
dev.touch_calibrated = calibrate_touch(&dev);
if (ev.type == EV_SYN) {
if (ev.code == SYN_MT_REPORT) {
dev.saw_mt_report = 1;
if (!dev.saw_mt_tracking_id) {
if (dev.saw_pos_x && dev.saw_pos_y) {
dev.saw_pos_x = 0;
dev.saw_pos_y = 0;
} else
handle_release(&dev, &ev);
}
}
} else if (ev.type == EV_REL) {
if (ev.code == REL_Y) {
// accumulate the up or down motion reported by
// the trackball. When it exceeds a threshold
// (positive or negative), fake an up/down
// key event.
rel_sum += ev.value;
if (rel_sum > 3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_DOWN;
ev.value = 1;
rel_sum = 0;
} else if (rel_sum < -3) {
fake_key = 1;
ev.type = EV_KEY;
ev.code = KEY_UP;
ev.value = 1;
rel_sum = 0;
}
}
} else if (ev.type == EV_ABS) {
switch(ev.code){
case ABS_MT_SLOT:
dev.slot_current = ev.value;
break;
case ABS_MT_TRACKING_ID:
dev.saw_mt_tracking_id = 1;
dev.tracking_id = ev.value;
if (dev.tracking_id == -1 && dev.slot_current == 0)
handle_release(&dev, &ev);
break;
case ABS_MT_POSITION_X:
dev.saw_pos_x = 1;
if (dev.slot_current != 0) break;
if(dev.touch_start.x == 0)
dev.touch_start.x = dev.touch_pos.x;
float touch_rel = (float)ev.value / ((float)dev.touch_max.x - (float)dev.touch_min.x);
dev.touch_pos.x = touch_rel * gr_fb_width();
if (dev.touch_start.x == 0) break; //first touch.
diff_x += dev.touch_pos.x - dev.touch_start.x;
if (abs(diff_x) > abs(diff_y) && dev.touch_pos.y < (gr_fb_height() - virtualkey_h)) {
if(diff_x > min_x_swipe_px) {
dev.slide_right = 1;
} else if (diff_x < -min_x_swipe_px) {
dev.slide_left = 1;
}
}
break;
case ABS_MT_POSITION_Y:
dev.saw_pos_y = 1;
if (dev.slot_current != 0) break;
if(dev.touch_start.y == 0)
dev.touch_start.y = dev.touch_pos.y;
touch_rel = (float)ev.value / ((float)dev.touch_max.y - (float)dev.touch_min.y);
dev.touch_pos.y = touch_rel * gr_fb_height();
#ifdef USE_VIRTUAL_KEY
ui_get_virtualkey_pressed(&dev);
#endif
if (dev.touch_start.y == 0) break; //first touch.
diff_y += dev.touch_pos.y - dev.touch_start.y;
if (abs(diff_y) >= abs(diff_x) && dev.touch_pos.y < (gr_fb_height() - virtualkey_h)) {
if (diff_y > min_y_swipe_px) {
ev.type = EV_KEY;
ev.code = KEY_VOLUMEDOWN;
ev.value = 2;
reset_touch(&dev);
} else if (diff_y < -min_y_swipe_px) {
ev.type = EV_KEY;
ev.code = KEY_VOLUMEUP;
ev.value = 2;
reset_touch(&dev);
}
}
break;
default:
break;
}
} else if (ev.type == EV_KEY) {
if (dev.saw_mt_report && dev.saw_mt_tracking_id && ev.code == BTN_TOUCH && ev.value == 0)
handle_release(&dev, &ev);
} else {
rel_sum = 0;
}
if (ev.type != EV_KEY || ev.code > KEY_MAX)
return 0;
if (ev.value == 2) {
boardEnableKeyRepeat = 0;
}
pthread_mutex_lock(&key_queue_mutex);
if (!fake_key) {
// our "fake" keys only report a key-down event (no
// key-up), so don't record them in the key_pressed
// table.
key_pressed[ev.code] = ev.value;
}
const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);
if (ev.value > 0 && key_queue_len < queue_max) {
key_queue[key_queue_len++] = ev.code;
if (boardEnableKeyRepeat) {
struct timeval now;
gettimeofday(&now, NULL);
key_press_time[ev.code] = (now.tv_sec * 1000) + (now.tv_usec / 1000);
key_last_repeat[ev.code] = 0;
}
pthread_cond_signal(&key_queue_cond);
}
pthread_mutex_unlock(&key_queue_mutex);
if (ev.value > 0 && device_reboot_now(key_pressed, ev.code)) {
reboot_main_system(ANDROID_RB_RESTART, 0, 0);
}
return 0;
}
