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