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