android sensor hal,Android Sensors HAL调试

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

//--------------------------------------------------------------------------------------------------------

#include "SensorBase.h"

//--------------------------------------------------------------------------------------------------------

#ifdef LOG_TAG

#undef LOG_TAG

#endif

#define LOG_TAG"SensorBase"

#define YLOGD(...) LOGD(__VA_ARGS__)

#define YLOGI(...) LOGI(__VA_ARGS__)

#define YLOGE(...) LOGE(__VA_ARGS__)

#define YLOGW(...) LOGW(__VA_ARGS__)

//--------------------------------------------------------------------------------------------------------

SensorBase::SensorBase(constchar*name):name(name),data_fd(-1),mHasPendingEvent(false),mEnabled(0)

{

data_fd=(name);

// sysfs classpath read

if(getInputClasspath(name)<0)YLOGE("getInputClasspath failed [%s]\n",name);

YLOGD("SensorBase::SensorBase : [Name : %s, data_fd : %d, classname : %s]\n",name,data_fd,classpath);

}

//--------------------------------------------------------------------------------------------------------

SensorBase::~SensorBase(){

if(data_fd>=0)close(data_fd);

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getFd()const{

returndata_fd;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::setDelay(int32_t handle,int64_t ns){

interr=0;

intmsDelay=(int)(ns/1000000LL);// convert to ms

YLOGD("SensorBase::setDelay : [Name : %s, Handle : %d, ns : %lld, delay = %d]\n",name,handle,ns,msDelay);

if(setInputAttr("delay",msDelay)<0){

YLOGE("setInputAttr failed -> delay : [%s]\n",name);err=-1;

}

returnerr;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::enable(int32_t handle,intenabled){

interr=0;

YLOGD("SensorBase::enable : [Name : %s, Handle : %d, enabled : %d]\n",name,handle,enabled);

// class path -> set enable, set wake

if(setInputAttr("enable",enabled)<0){

YLOGE("setInputAttr failed -> enable : [%s]\n",name);err=-1;

}

if(setInputAttr("wake",enabled)<0){

YLOGE("setInputAttr failed -> wake : [%s]\n",name);err=-1;

}

mEnabled=enabled;mHasPendingEvent=true;

returnerr;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getInitialValues(sensors_vec_t*sensor,floatdivf){

charbuf[sizeof("-2147483647")*3+1];/* including spaces, LF and '\0' */

char*p,space[]=" ";

inti;

if(getInputAttr("data",buf,sizeof(buf))<0){

for(i=0;i<3;i++)sensor->v[i]=0;

return0;

}

for(i=0;i<3;i++){

if(i==0)p=strtok(buf,space);

elsep=strtok(NULL,space);

if(p==NULL)sensor->v[i]=0;

elsesensor->v[i]=atoi(p)/divf;

YLOGD("initial value[%s] [%.3f]\n",name,sensor->v[i]);

}

return0;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getInitialStatus(sensors_vec_t*sensor){

intstatus;

if(getInputAttr("status",&status)<0)sensor->status=0;

elsesensor->status=(int8_t)status;

YLOGD("SensorBase::getInitialStatus : [Name : %s, status : %d]\n",name,status);

return0;

}

//--------------------------------------------------------------------------------------------------------

boolSensorBase::hasPendingEvents()const{

returnmHasPendingEvent;

}

//--------------------------------------------------------------------------------------------------------

int64_t SensorBase::getTimestamp(){

structtimespec t;

t.tv_sec=t.tv_nsec=0;

clock_gettime(CLOCK_MONOTONIC,&t);

returnint64_t(t.tv_sec)*1000000000LL+t.tv_nsec;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getInputClasspath(constchar*inputName){

DIR*dir;

constchar*dirname="/sys/class/input";

charbuf[PATH_MAX];

structdirent*de;

intfd=-1,nread,found=0;

if(name==NULL||classpath==NULL)return-EINVAL;

// Open Input class dir

if((dir=opendir(dirname))==NULL)return-errno;

while((de=readdir(dir))){

if(strncmp(de->d_name,"input",strlen("input"))!=0)continue;

memset(classpath,0x00,sizeof(classpath));

snprintf(classpath,PATH_MAX,"%s/%s/",dirname,de->d_name);

snprintf(buf,sizeof(buf),"%s/name",classpath);

if((fd=open(buf,O_RDONLY))<0)continue;

if((nread=read(fd,buf,sizeof(buf)))<0){

close(fd);

continue;

}

buf[nread-1]='\0';

if(strcmp(buf,inputName)==0){

close(fd);closedir(dir);return0;// Classpath found!!

}

close(fd);fd=-1;

}

closedir(dir);*classpath='\0';

return-EINVAL;// Classpath not found

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getInputAttr(constchar*attr,char*value,intlen){

charfname[PATH_MAX];

intfd,nread;

if(classpath==NULL||*classpath=='\0'||attr==NULL||value==NULL||len<1)return-EINVAL;

memset(fname,0x00,sizeof(fname));

snprintf(fname,sizeof(fname),"%s/%s",classpath,attr);fname[sizeof(fname)-1]='\0';

if((fd=open(fname,O_RDONLY))<0)return-errno;

if((nread=read(fd,value,len))<0){

close(fd);return-errno;

}

close(fd);

value[nread-1]='\0';

return0;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::getInputAttr(constchar*attr,int*value){

charbuf[sizeof("-2147483647")];

intrt;

if(value==NULL)return-EINVAL;

if((rt=getInputAttr(attr,buf,sizeof(buf)))<0)returnrt;

*value=atoi(buf);

return0;

}

//--------------------------------------------------------------------------------------------------------

intSensorBase::setInputAttr(constchar*attr,char*value,intlen){

charfname[PATH_MAX];

intfd;

if(classpath==NULL||*classpath=='\0'||attr==NULL||value==NULL||len<1)return-EINVAL;

memset(fname,0x00,sizeof(fname));

snprintf(fname,sizeof(fname),"%s/%s",classpath,attr);fname[sizeof(fname)-1]='\0';

if((fd=open(fname,O_WRONLY))<0)return-errno;

if(write(fd,value,len)<0){

close(fd);return-errno;

}

close(fd);

return0;

}

intSensorBase::setInputAttr(constchar*attr,intvalue){

charbuf[sizeof("-2147483647")];

memset(buf,0x00,sizeof(buf));

sprintf(buf,"%d",value);

returnsetInputAttr(attr,buf,sizeof(buf));

}

intSensorBase::openDataFd(constchar*inputName){

DIR*dir;

structdirent*de;

constchar*dirname="/dev/input";

char*filename,devname[PATH_MAX];

intfd=-1;

if((dir=opendir(dirname))==NULL)return-1;

memset(devname,0x00,sizeof(devname));strcpy(devname,dirname);

filename=devname+strlen(devname);*filename++='/';

while((de=readdir(dir))){

if(de->d_name[0]=='.'&&(de->d_name[1]=='\0'||(de->d_name[1]=='.'&&de->d_name[2]=='\0')))

continue;

strcpy(filename,de->d_name);

if((fd=open(devname,O_RDONLY))>=0){

charname[80];

if(ioctl(fd,EVIOCGNAME(sizeof(name)-1),&name)<1)name[0]='\0';

if(!strcmp(name,inputName))break;

else{

close(fd);fd=-1;

}

}

}

closedir(dir);

LOGE_IF(fd<0,"couldn't find '%s' input device",inputName);

returnfd;

}