static int open_sensors(const struct hw_module_t* module, const char* name, struct hw_device_t** device) { int status = -EINVAL; struct sensors_poll_context_t *dev = malloc( sizeof(struct sensors_poll_context_t)); memset(&dev->device, 0, sizeof(struct sensors_poll_device_t)); dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = 0; dev->device.common.module = (struct hw_module_t*) module; dev->device.common.close = common__close; dev->device.activate = device__activate; dev->device.setDelay = device__set_delay; dev->device.poll = device__poll; if ((dev->fd = open_input_device()) < 0) { LOGE("g sensor get class path error \n"); } else { *device = &dev->device.common; status = 0; } return status; }
static int get_gsensor(void) { struct input_event event; int fd; int ret = -1; int zero_value = 0; memset(&detect_value,0,sizeof(detect_value)); fd = open_input_device(); if(fd < 0 ){ ALOGD("%s:open input device erro!\n",__func__); return 0; } while (zero_value < 20) { ret = read(fd, &event, sizeof(event)); if(ret < 0){ ALOGD("%s:can't read!\n",__func__); } switch (event.code) { case ABS_MISC: if(event.value != 0){ detect_value[detect_num++] = event.value; #ifdef DEBUG_SENSOR ALOGD("detect_value[%d]:%d",detect_num-1,detect_value[detect_num-1]); #endif }else{ zero_value++; } break; default: break; } if( detect_num == 2) { if(detect_value[0] == detect_value[1]) { close(fd); break; }else { ALOGD("detect_value is erro!\n"); close(fd); return 0; } } } rmmod("gsensor"); memset(&class_path,0,sizeof(class_path)); memset(&sensor_name,0,sizeof(sensor_name)); ret = (zero_value != 20) ? 1 : 0; return ret; }
static int sensor_init(struct sensors_poll_context_t *dev) { int ret = -1; strcpy(class_path,"\0"); strcpy(sensor_name,"\0"); if(sensor_get_class_path() < 0) { ALOGD("sensor get class path error \n"); return 0; } if(!(ret = gsensor_cfg())){ ALOGD("gsensor config error!\n"); return 0; } dev->fd = 0; dev->fd = open_input_device(); if(dev->fd <0) { ALOGD("%s:open device error!",__func__); return 0; } return 1; }
int main(int argc, char **argv) { int ret, size; int fd = -1, fdv = -1, ls; struct input_event ev; struct pollfd fds[3]; int num_fds = 0; struct sigaction sa_int; /* * initialize our state */ daemonize(argv[0]); #ifdef DEBUG_PRINT console = fopen("/dev/console", "w"); if(console == NULL) exit(1); #endif if (sound_connect()) goto fail_sound; running = 0; if (backlight_connect() == 0) backlight = 1; fd = open_input_device("LF1000 Keyboard"); if (fd < 0) { dbprintf("can't open input device\n"); goto fail_kb; } fds[LFD_KEY_PRESS].fd = fd; fds[LFD_KEY_PRESS].events = POLLIN; num_fds++; /* volume fd open */ fdv = open_input_device("OpenLF Didj volume interface"); if (fdv < 0) { dbprintf("can't open volume input device\n"); goto fail_kb; } fds[LFD_VOLUME].fd = fdv; fds[LFD_VOLUME].events = POLLIN; num_fds++; ls = create_listening_socket(LFD_SOCKET_PATH); if (ls < 0) { dbprintf("can't create listening socket\n"); goto fail_sock; } fcntl(ls, F_SETFL, O_NONBLOCK); fds[LFD_CONTROL_SOCKET].fd = ls; fds[LFD_CONTROL_SOCKET].events = POLLIN; num_fds++; mv = battery_get_mv(); /* * trap SIGTERM so that we clean up before exiting */ running = 1; sigemptyset(&sa_int.sa_mask); sa_int.sa_handler = handle_signal; sa_int.sa_flags = 0; if (sigaction(SIGTERM, &sa_int, NULL) == -1) { dbprintf("can't trap SIGTERM\n"); goto fail_sig; } if (sigaction(SIGINT, &sa_int, NULL) == -1) { dbprintf("can't trap SIGINT\n"); goto fail_sig; } /* * monitor */ while (running) { ret = poll(fds, num_fds, 1000); if (ret == 0) { /* timeout */ mv = battery_get_mv(); } else if (ret > 0) { if (fds[LFD_KEY_PRESS].revents & POLLIN) { size = read(fd, &ev, sizeof(ev)); if (ev.type == EV_KEY && ev.value == 1) handle_key(ev.code); } if(fds[LFD_VOLUME].revents & POLLIN) { size = read(fdv, &ev, sizeof(ev)); if (ev.type == EV_ABS) handle_volume(ev.value); } if (fds[LFD_CONTROL_SOCKET].revents & POLLIN) handle_control_socket(ls); } } dbprintf("exiting...\n"); close(ls); close(fd); sound_disconnect(); #ifdef DEBUG_PRINT fclose(console); #endif exit(0); fail_sig: close(ls); fail_sock: fail_sound: close(fd); close(fdv); fail_kb: sound_disconnect(); #ifdef DEBUG_PRINT fclose(console); #endif exit(1); }
/* * Create input line */ struct evf_line *evf_line_create(const char *input_device, void (*commit)(struct input_event *ev, void *priv), void *priv, unsigned int use_barriers, union evf_err *err, int even_empty) { struct evf_line *line; struct evf_filter *fcommit; struct evf_filter *begin; struct evf_filter *fbarrier = NULL; int fd; fd = open_input_device(input_device, err); if (fd < 0) return NULL; begin = evf_load_system_profile(fd, err); /* err is filled from evf_load_system_profile */ if (err->type != evf_ok) { close(fd); return NULL; } /* we should not create empty line */ if (!even_empty && begin == NULL) { err->type = evf_ok; close(fd); return NULL; } /* let's the allocation begins ;) */ line = malloc(sizeof (struct evf_line) + strlen(input_device) + 1); if (line == NULL) { err->type = evf_errno; err->err_no.err_no = errno; evf_filters_free(begin); close(fd); evf_msg(EVF_ERR, "Allocating error"); return NULL; } /* load system profiles */ line->begin = begin; line->end = evf_filters_last(begin); fcommit = evf_commit_alloc(commit, priv); if (use_barriers) fbarrier = evf_barrier_alloc(use_barriers); if (fcommit == NULL || (use_barriers && fbarrier == NULL)) { err->type = evf_errno; err->err_no.err_no = errno; free(fcommit); free(fbarrier); evf_filters_free(line->begin); free(line); close(fd); return NULL; } /* build the structure in memory */ line->fd = fd; strcpy(line->input_device, input_device); if (use_barriers) fbarrier->next = fcommit; else fbarrier = fcommit; if (line->begin == NULL) line->begin = fbarrier; else line->end->next = fbarrier; return line; }
int main(int argc, char *argv[]) { char dev_path[64]; int fd; int x=0; int y=0; int z=0; struct input_event event; char buf[64]; char class_path[256]; int ret; INIT_CMD_PIPE(); if(sensor_get_class_path(class_path,argv[4]) < 0) { db_error("can't get the sensor class path\n"); goto err; } ret=sprintf(buf,"%d",1); if(0!=set_sysfs_input_attr(class_path,"enable",buf,ret)){ db_warn("can't set sensor enable!!! (%s)\n", strerror(errno)); } fd=open_input_device(argv[4]); if (fd== -1) { db_error("can't open %s(%s)\n",argv[4], strerror(errno)); goto err; } /* strncpy(dev_path, "/dev/input/event2", 64); fd= open(dev_path, O_RDONLY); if (fd== -1) { db_error("can't open %s(%s)\n", dev_path, strerror(errno)); goto err; } */ while(1){ ret = read(fd, &event, sizeof(event)); if(ret==-1){ db_error("can't read %s(%s)\n", dev_path, strerror(errno)); goto err; } if (event.type == EV_ABS) { switch (event.code) { case ABS_X: x =event.value; //db_msg("senser data is: x=%d\n",x); break; case ABS_Y: y =event.value; // db_msg("senser date is: y=%d\n",y); break; case ABS_Z: z =event.value; // db_msg("senser date is:z=%d\n",z); break; } sprintf(buf,"(%d,%d,%d)",x,y,z); //db_msg("senser data is:x=%d,y=%d,z=%d\n",x,y,z); SEND_CMD_PIPE_OK_EX(buf); } sleep(1); } close(fd); err: SEND_CMD_PIPE_FAIL(); EXIT_CMD_PIPE(); return 0; }