自学教程：C++ timevalToNano函数代码示例

int BladeLight::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_LIGHT) {                LOGD_IF(DEBUG,"Light value=%i",event->value);                mPendingEvents.light = event->value;            }        } else if (type == EV_SYN) {             int64_t time = timevalToNano(event->time);             if (mEnabled) {                 *data++ = mPendingEvents;                 mPendingEvents.timestamp=time;                 count--;                 numEventReceived++;             }        } else {            LOGE("BladeLight: unknown event (type=%d, code=%d)",type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int SensorKXTF9::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event))    {        int type = event->type;        if (type == EV_ABS)        {            processEvent(event->code, event->value);        }        else if (type == EV_SYN)        {            mPendingEvent.timestamp = timevalToNano(event->time);            *data++ = mPendingEvent;            count--;            numEventReceived++;        }        else        {            LOGE("SensorKXTF9: unknown event (type=%d, code=%d, value=%d)", type, event->code, event->value);        }        mInputReader.next();    }    return numEventReceived;}

int TaosProximity::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_PROXIMITY) {                LOGD_IF(DEBUG,"Prox value=%i",event->value);                mPendingEvents.distance = indexToValue(event->value);            }        } else if (type == EV_SYN) {            int64_t time = timevalToNano(event->time);            if (mEnabled){                *data++ = mPendingEvents;                mPendingEvents.timestamp=time;                count--;                numEventReceived++;            }        } else {            LOGE("TaosSensor: unknown event (type=%d, code=%d)",type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int AccelSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;#if FETCH_FULL_EVENT_BEFORE_RETURNagain:#endif    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            float value = event->value;            if (event->code == EVENT_TYPE_ACCEL_Y) {                mPendingEvent.data[0] = value * CONVERT_A_Y;            } else if (event->code == EVENT_TYPE_ACCEL_X) {                mPendingEvent.data[1] = value * CONVERT_A_X;            } else if (event->code == EVENT_TYPE_ACCEL_Z) {                mPendingEvent.data[2] = value * CONVERT_A_Z;            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            ALOGE("AccelSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }#if FETCH_FULL_EVENT_BEFORE_RETURN    /* if we didn't read a complete event, see if we can fill and       try again instead of returning with nothing and redoing poll. */    if (numEventReceived == 0 && mEnabled == 1) {        n = mInputReader.fill(data_fd);        if (n)            goto again;    }#endif    return numEventReceived;}

int ProximitySensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_PROXIMITY) {                if (event->value != -1) {                    // FIXME: not sure why we're getting -1 sometimes                    mPendingEvent.distance = indexToValue(event->value);                }            }        } else if (type == EV_SYN) {                switch ( event->code ) {                        case SYN_TIME_SEC:                                mUseAbsTimeStamp = true;                                report_time = event->value * 1000000000LL;                                break;                        case SYN_TIME_NSEC:                                mUseAbsTimeStamp = true;                                mPendingEvent.timestamp = report_time + event->value;                                break;                        case SYN_REPORT:                                if(mUseAbsTimeStamp != true) {                                        mPendingEvent.timestamp = timevalToNano(event->time);                                }                                if (mEnabled) {                                        *data++ = mPendingEvent;                                        count--;                                        numEventReceived++;                                }                                break;                }        } else {            ALOGE("ProximitySensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int AccelerationSensor::readEvents(sensors_event_t* data, int count){    //ALOGD("AccelerationSensor::~readEvents() %d", count);    if (count < 1)        return -EINVAL;            if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }            ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;	    while (count && mInputReader.readEvent(&event)) {	 if(event == NULL)	 {	     ALOGE("llw AccelerationSensor::readEvents()  null pointer!!!" );	 }	 else	 {	            int type = event->type;            if (type == EV_ABS) {                float value = event->value;                if (event->code == EVENT_TYPE_ACCEL_X) {                    mPendingEvent.acceleration.x = value * mResolution;                } else if (event->code == EVENT_TYPE_ACCEL_Y) {                    mPendingEvent.acceleration.y = value * mResolution;                } else if (event->code == EVENT_TYPE_ACCEL_Z) {                    mPendingEvent.acceleration.z = value * mResolution;                }            } else if (type == EV_SYN) {                mPendingEvent.timestamp = timevalToNano(event->time);                if (mEnabled) {                    *data++ = mPendingEvent;                    count--;                    numEventReceived++;                }            } else {                ALOGE("AccelerationSensor: unknown event (type=%d, code=%d)",                        type, event->code);            }    	 }        mInputReader.next();    } 	//ALOGD("AccelerationSensor::~readEvents() numEventReceived = %d", numEventReceived);	return numEventReceived;		}

int GyroscopeSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mPendingEventsFlushCount > 0) {        sensors_meta_data_event_t flushEvent;        flushEvent.version = META_DATA_VERSION;        flushEvent.type = SENSOR_TYPE_META_DATA;        flushEvent.meta_data.what = META_DATA_FLUSH_COMPLETE;        flushEvent.meta_data.sensor = mPendingEvents.sensor;        flushEvent.reserved0 = 0;        flushEvent.timestamp = getTimestamp();        *data++ = flushEvent;        mPendingEventsFlushCount--;        count--;        numEventReceived++;    }    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_REL) {            float value = event->value;            if (event->code == EVENT_TYPE_GYRO_X) {                mPendingEvents.gyro.x = value * CONVERT_G_X;            } else if (event->code == EVENT_TYPE_GYRO_Y) {                mPendingEvents.gyro.y = value * CONVERT_G_Y;            } else if (event->code == EVENT_TYPE_GYRO_Z) {                mPendingEvents.gyro.z = value * CONVERT_G_Z;            } else {                ALOGE("Gyroscope: unknown event (type=%d, code=%d)",                        type, event->code);            }        } else if (type == EV_SYN) {            mPendingEvents.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvents;                count--;                numEventReceived++;            }        } else {            ALOGE("Gyroscope: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int AccSensor::readEvents(sensors_event_t * data, int count){	if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if ((type == EV_ABS) || (type == EV_REL) || (type == EV_KEY)) {            switch (event->code) {				case ACC_EVENT_X :				    mPendingMask = 1;				    mPendingEvent.acceleration.x = ACC_UNIT_CONVERSION(event->value);				    break;				case ACC_EVENT_Y :				    mPendingMask = 1;				    mPendingEvent.acceleration.y = ACC_UNIT_CONVERSION(event->value);				    break;				case ACC_EVENT_Z :				    mPendingMask = 1;				    mPendingEvent.acceleration.z = ACC_UNIT_CONVERSION(event->value);				    break;			}            mInputReader.next();        } else if (type == EV_SYN) {            int64_t time = timevalToNano(event->time);			if (mPendingMask) {				mPendingMask = 0;				mPendingEvent.timestamp = time;				if (mEnabled) {					mSensorCoordinate.coordinate_data_convert(						mPendingEvent.acceleration.v, INSTALL_DIR);					*data++ = mPendingEvent;					count--;					numEventReceived++;				}			}            if (!mPendingMask) {                mInputReader.next();            }        } else {            ALOGE("FslAccSensor: unknown event (type=%d, code=%d)",                    type, event->code);            mInputReader.next();        }    }    return numEventReceived;}

/** Reading sensor events generated by input event subsystem in kernel driver.*/int ProximitySensor::readEvents (sensors_event_t* data, int count) {	if (count < 1) {		return -EINVAL;	}	if (mHasPendingEvent) {		mHasPendingEvent = false;		mPendingEvent.timestamp = getTimestamp();		*data = mPendingEvent;		return mEnabled ? 1 : 0;	}	// data_fd technically set in super class constructor but value got overwritten	// so data_fd is set new	data_fd = openInput("SRF02 input event module");	ssize_t n = mInputReader.fill(data_fd);	if (n < 0) {		return n;	}	int numEventRecieved = 0;	input_event const* event;	while (count && mInputReader.readEvent(&event)) {		// evaluating event type set in kernel driver		int type = event->type;		// ALOGD("sensor in ProximitySensor readEvents() - event->type is: %d", type);		if (type == EV_ABS) {			if (event->code == ABS_DISTANCE) {				// ALOGD("sensor in ProximitySensor readEvents() in if event->code == ABS_DISTANCE -> input event kernel");				mPendingEvent.sensor = ID_PX;				mPendingEvent.type = SENSOR_TYPE_PROXIMITY;				mPendingEvent.distance = (float) event->value;				// ALOGD("sensor srf02 - value is : %d	/n ", event->value);			}		}		else if (type == EV_SYN) {			// ALOGD("sensor in ProximitySensor readEvents() in if type == EV_SYN");			mPendingEvent.timestamp = timevalToNano(event->time);			if (mEnabled) {				*data++ = mPendingEvent;				count--;				numEventRecieved++;			}		}		else {			ALOGE ("ProximitySensor: unknown event (type=%d, code=%d)", type, event->code);		}		mInputReader.next();		mHasPendingEvent=true;	}	return numEventRecieved;}

int TSL2771Sensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_LED) {            if (event->code == EVENT_TYPE_LIGHT) {                mPendingEvents[light].light = event->value;                mPendingMask |= 1 << light;                mInputReader.next();#ifdef DEBUG_TSL2771                ALOGD("TSL2771Sensor: Received LUX value=%d", event->value);#endif            }        } else if (type == EV_ABS) {            if (event->code == EVENT_TYPE_PROXIMITY) {                mPendingEvents[proximity].distance = indexToValue(event->value);                mPendingMask |= 1 << proximity;                mInputReader.next();#ifdef DEBUG_TSL2771                ALOGD("TSL2771Sensor: Received Proximity value=%d", event->value);#endif            }        } else if (type == EV_SYN) {           int64_t time = timevalToNano(event->time);            for (int j=0 ; count && mPendingMask && j<numSensors ; j++) {              if (mPendingMask & (1 << j)) {                    mPendingMask &= ~(1 << j);                    mPendingEvents[j].timestamp = time;                    *data++ = mPendingEvents[j];                        count--;                        numEventReceived++;              }            }            if (!mPendingMask) {                mInputReader.next();            }        } else {            ALOGE("TSL2771Sensor: unknown event (type=%d, code=%d)",                    type, event->code);        }    }    return numEventReceived;}

int OrientationSensor::readEvents(sensors_event_t* data, int count){    //LOGD("OrientationSensor::~readEvents() %d", count);    if (count < 1)        return -EINVAL;            if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }            ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;	    while (count && mInputReader.readEvent(&event)) {        int type = event->type;            /*LOGE("OrientationSensor: unknown event (type=%d, code=%d, value=%d)",                    type, event->code,event->value);*/        if (type == EV_ABS) {            float value = event->value;            if (event->code == EVENT_TYPE_YAW) {                mPendingEvent.orientation.azimuth = value * CONVERT_O_A;            } else if (event->code == EVENT_TYPE_PITCH) {                mPendingEvent.orientation.pitch = value * CONVERT_O_P;            } else if (event->code == EVENT_TYPE_ROLL) {                mPendingEvent.orientation.roll = value * CONVERT_O_R;            }else {            LOGE("OrientationSensor: unknown event (type=%d, code=%d)",                    type, event->code);}        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            LOGE("OrientationSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    } 	//LOGD("OrientationSensor::~readEvents() numEventReceived = %d", numEventReceived);	return numEventReceived++;		}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;            pthread_mutex_lock(&mLock);    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }        //    ssize_t n = mInputReader.fill(data_fd);//    if (n < 0)//        return n;      int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(data_fd,&event)) {        int type = event->type;        if (type == EV_REL) {            if (event->code == REL_X) {                // Convert adc value to lux assuming:                // I = 10 * log(Ev) uA                // R = 47kOhm                // Max adc value 4095 = 3.3V                // 1/4 of light reaches sensor//                mPendingEvent.light = powf(10, event->value * (330.0f / 4095.0f / 47.0f)) * 4;				mPendingEvent.light = event->value;            }        } else if (type == EV_SYN) {//        	ALOGE("LightSensor: lux = %f ++++++++++++++++++++++",mPendingEvent.light);            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            ALOGE("LightSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    } 	//LOGD("GyroscopeSensor::~readEvents() numEventReceived = %d", numEventReceived);  pthread_mutex_unlock(&mLock);	return numEventReceived++;		 }

int GyroSensor::readEvents(sensors_event_t* data, int count){        static int64_t prev_time;        int64_t time;        if (count < 1)                return -EINVAL;                        if(data_fd < 0)                return 0;        ssize_t n = mInputReader.fill(data_fd);        if (n < 0)                return n;        int numEventReceived = 0;        input_event const* event;        while (count && mInputReader.readEvent(&event)) {                int type = event->type;                                if (type == EV_ABS) {                        processEvent(event->code, event->value);                        mInputReader.next();                        }else if (type == EV_SYN) {                        time = timevalToNano(event->time);                                                if (mPendingMask) {				mPendingMask = 0;				mPendingEvent.timestamp = time;								if (mEnabled) {					*data++ = mPendingEvent;					count--;					numEventReceived++;				}							}			                        if (!mPendingMask) {                                mInputReader.next();                        }                                        } else {                        ALOGE("AccelSensor: unknown event (type=%d, code=%d)",                                type, event->code);                        mInputReader.next();                }        }        return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0){        LOGE("LightSensor::readEvents mInputReader.fill failed!!");        return n;    }    int numEventReceived = 0;    input_event const* event;        while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == ABS_X) {                mPendingEvent.light = event->value ; //  indexToValue(event->value);                if (mEventsSinceEnable < FIRST_GOOD_EVENT)                    mEventsSinceEnable++;            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled && (mPendingEvent.light != mPreviousLight) &&                    mEventsSinceEnable >= FIRST_GOOD_EVENT) {                *data++ = mPendingEvent;                count--;                numEventReceived++;                mPreviousLight = mPendingEvent.light;                #ifdef DBG_LIGHT                    LOGE("light_sensor:data->sensor =%d,data->type=%d,mPendingEvent.light=%f",                        data->sensor ,data->type ,mPendingEvent.light);                #endif            }        } else {            LOGE("LightSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int AccelSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent)    {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event))    {        int type = event->type;        if (type == EV_ABS)        {            if (event->code == EVENT_TYPE_ACCEL_X)                mPendingEvent.acceleration.x = event->value * CONVERT_A;            else if (event->code == EVENT_TYPE_ACCEL_Y)                mPendingEvent.acceleration.y = event->value * CONVERT_A;            else if (event->code == EVENT_TYPE_ACCEL_Z)                mPendingEvent.acceleration.z = event->value * CONVERT_A;        }        else if (type == EV_SYN)        {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled)            {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            ALOGE("AccelSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int InputEventSensor::getData(std::queue<sensors_event_t> &eventQue) {        struct input_event inputEvent[32];        int count, ret;        ret = read(pollfd, inputEvent, 32 * sizeof(struct input_event));        if (ret < 0 || ret % sizeof(struct input_event)) {                log_message(CRITICAL,"Read input event error! ret: %d", ret);                return -1;        }        count = ret / sizeof(struct input_event);        for (int i = 0; i < count; i++) {                if ((inputEvent[i].type == EV_REL || inputEvent[i].type == EV_ABS) && !inputDataOverrun) {					 log_message(CRITICAL,"in EV_REL/n");                         float value = SensorHubHelper::ConvertToFloat(inputEvent[i].value, device.getType());                      if ((inputEvent[i].type == EV_REL && inputEvent[i].code == REL_X) ||                            (inputEvent[i].type == EV_ABS && inputEvent[i].code == ABS_X))                                event.data[device.getMapper(AXIS_X)] = value * device.getScale(AXIS_X);                        else if ((inputEvent[i].type == EV_REL && inputEvent[i].code == REL_Y) ||                                 (inputEvent[i].type == EV_ABS && inputEvent[i].code == ABS_Y))                                event.data[device.getMapper(AXIS_Y)] = value * device.getScale(AXIS_Y);                        else if ((inputEvent[i].type == EV_REL && inputEvent[i].code == REL_Z) ||                                 (inputEvent[i].type == EV_ABS && inputEvent[i].code == ABS_Z))                                event.data[device.getMapper(AXIS_Z)] = value * device.getScale(AXIS_Z);                }                else if (inputEvent[i].type == EV_SYN) {   					 log_message(CRITICAL,"in EV_SYN/n");                     if (inputEvent[i].code == SYN_DROPPED) {                                log_message(CRITICAL,"input event overrun");                                inputDataOverrun = true;                        }                        else if (inputDataOverrun) {                                inputDataOverrun = false;                        }                        else {                                event.timestamp = timevalToNano(inputEvent[i].time);                                if (Calibration != NULL)                                        Calibration(&event, CALIBRATION_DATA, data.calibrationFile.c_str());                                else if (device.getEventProperty() == VECTOR)                                        event.acceleration.status = SENSOR_STATUS_ACCURACY_MEDIUM;                                eventQue.push(event);                        }                }        }        return 0;}

int AccelerationSensor::readEvents(sensors_event_t* data, int count){    //ALOGE("fwq read Event 1/r/n");    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;		//ALOGE("fwq1..../r/n");        if (type == EV_ABS) 		{            processEvent(event->code, event->value);			//ALOGE("fwq2..../r/n");        } 		else if (type == EV_SYN)         {            //ALOGE("fwq3..../r/n");            int64_t time = timevalToNano(event->time);            mPendingEvent.timestamp = time;            if (mEnabled) 			{                 //ALOGE("fwq4..../r/n");			     if (mPendingEvent.timestamp >= mEnabledTime) 				 {				    //ALOGE("fwq5..../r/n");				 	*data++ = mPendingEvent;					numEventReceived++;			     }                 count--;                            }        } 		else if (type != EV_ABS)         {             ALOGE("AccelerationSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }	//ALOGE("fwq read Event 2/r/n");    return numEventReceived;}

int CompassSensor::readEvents(sensors_event_t* data, int count){    //LOGD("CompassSensor::readEvents() %d", count);    if (count < 1)        return -EINVAL;            if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }            ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;	    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            float value = event->value;            if (event->code == EVENT_TYPE_MAGV_X) {                mPendingEvent.magnetic.x = value * CONVERT_M_X;            } else if (event->code == EVENT_TYPE_MAGV_Y) {                mPendingEvent.magnetic.y = value * CONVERT_M_Y;            } else if (event->code == EVENT_TYPE_MAGV_Z) {                mPendingEvent.magnetic.z = value * CONVERT_M_Z;            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            LOGE("CompassSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    } 	//LOGD("CompassSensor::~readEvents() numEventReceived = %d", numEventReceived);	return numEventReceived++;		}

int AccSensor::readEvents(sensors_event_t * data, int count){	if (count < 1)		return -EINVAL;	if (mHasPendingEvent) {		mHasPendingEvent = false;		mPendingEvent.timestamp = getTimestamp();		*data = mPendingEvent;		return mEnabled ? 1 : 0;	}	ssize_t n = mInputReader.fill(data_fd);	if (n < 0)		return n;	int numEventReceived = 0;	input_event const *event;	while (count && mInputReader.readEvent(&event)) {		int type = event->type;		if (type == EV_ABS) {			float value = event->value;			if (event->code == EVENT_TYPE_ACCEL_X) {				mPendingEvent.acceleration.x = ACC_UNIT_CONVERSION(value);			} else if (event->code == EVENT_TYPE_ACCEL_Y) {				mPendingEvent.acceleration.y = ACC_UNIT_CONVERSION(value);			} else if (event->code == EVENT_TYPE_ACCEL_Z) {				mPendingEvent.acceleration.z = ACC_UNIT_CONVERSION(value);			}		} else if (type == EV_SYN) {			mPendingEvent.timestamp = timevalToNano(event->time);			if (mEnabled) {				mSensorCoordinate.coordinate_data_convert(						mPendingEvent.acceleration.v, INSTALL_DIR);				*data++ = mPendingEvent;				count--;				numEventReceived++;			}		} else {			ALOGE("AccSensor: unknown event (type=%d, code=%d)",			      type, event->code);		}		mInputReader.next();	}	return numEventReceived;}

int ProximitySensor::readEvents(sensors_event_t* data, int count){    LOGD("LightSensor::readEvents count = %d", count);     if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {          //  processEvent(event->code, event->value);          //  mInputReader.next();           if (event->code == EVENT_TYPE_PROXIMITY) {          		   	// In distance mode, SenseTek driver will report 0(near) or 1 (far)         		   	// convert to float directly   		   	mPendingEvent.distance = ((float)event->value)*10.0f;       			LOGE("ProximitySensor readevents distance%f",mPendingEvent.distance);		}        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);         		if (mEnabled) {             			*data++ = mPendingEvent;         			count--;          			numEventReceived++;        		}        } else {            LOGE("STKProximitySensor: unknown event (type=%d, code=%d)",                    type, event->code);        }	   mInputReader.next();    }    return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    LOGD("LightSensor::readEvents count = %d", count);     if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            processEvent(event->code, event->value);            mInputReader.next();        } else if (type == EV_SYN) {            int64_t time = timevalToNano(event->time);            for (int j=0 ; count && mPendingMask && j<numSensors ; j++) {                if (mPendingMask & (1<<j)) {                    mPendingMask &= ~(1<<j);                    mPendingEvents[j].timestamp = time;					//LOGD("data=%8.5f,%8.5f,%8.5f",						//mPendingEvents[j].data[0],						//mPendingEvents[j].data[1],						//mPendingEvents[j].data[2]);                    if (mEnabled[j]) {                        *data++ = mPendingEvents[j];                        count--;                        numEventReceived++;                    }                }            }            if (!mPendingMask) {                mInputReader.next();            }        } else {            LOGE("AkmSensor: unknown event (type=%d, code=%d)",                    type, event->code);            mInputReader.next();        }    }    return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_LIGHT) {                // Convert adc value to lux assuming:                // I = 10 * log(Ev) uA                // R = 47kOhm                // Max adc value 4095 = 3.3V                // 1/4 of light reaches sensor                mPendingEvent.light = powf(10, event->value * (330.0f / 4095.0f / 47.0f)) * 4;            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            ALOGE("LightSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    D("LightSensor::%s", __func__);    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        D("LightSensor:%s, type = %d, code = %d, count = %d",                                                    __func__, type, event->code, count);        if (type == EV_ABS && !inputDataOverrun) {            float value = event->value;            if (event->code == ABS_MISC)                mPendingEvent.light = value * mGlassFactor;        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (event->code == SYN_DROPPED) {                LOGE("LightSensor: input event overrun, dropped event:drop");                inputDataOverrun = 1;            } else if (inputDataOverrun) {                LOGE("LightSensor: input event overrun, dropped event:sync");                inputDataOverrun = 0;            } else {                D("LightSensor::%s, in type = EV_SYN, mEnabled = %d", __func__, mEnabled);                if (mEnabled) {                    *data++ = mPendingEvent;                    count--;                    numEventReceived++;                }            }        } else {            LOGE("LightSensor: unknown event (type=%d, code=%d)", type, event->code);        }        mInputReader.next();    }    D("LightSensor::%s, return numEventReceived= %d", __func__, numEventReceived);    return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_LIGHT) {                if (event->value != -1) {                    LOGV("LightSensor: event (value=%d)", event->value);                    // FIXME: not sure why we're getting -1 sometimes                    mPendingEvent.light = event->value;                }            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            LOGE("LightSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int LightSensor29023::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_LIGHT) {                mPendingEvent.light = indexToValue(event->value);                #if SENSOR_DEBUG        		ALOGD_IF(SENSOR_DEBUG,"LightSensor29023::readEvents light =%f/n",mPendingEvent.light);        		#endif            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {                        ALOGE("LightSensor29023: unknown event (type=%d, code=%d)",                        type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int LightSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_LED) {            if (event->code == EVENT_TYPE_LIGHT) {                mPendingEvent.light = event->value;                ALOGD("LightSensor: Received LUX value=%d",                   event->value);            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mPendingEvent.light != mPreviousLight) {                *data++ = mPendingEvent;                count--;                numEventReceived++;                mPreviousLight = mPendingEvent.light;            }        } else {            ALOGE("LightSensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

// TODO readEventsint AccelerometerSensor::readEvents(sensors_event_t* data, int count) {	if(count < 1) {		return -EINVAL;	}	ssize_t n = mInputReader.fill(data_fd);	if(n < 0) {		return n;	}	int numEventReceived = 0;	input_event const* event;	while(count && mInputReader.readEvent(&event)) {		int type = event->type;		if(type == EV_ABS) {			processEvent(event->code, event->value);			mInputReader.next();		} else if (type == EV_SYN) {			int64_t time = timevalToNano(event->time);			for (int j = 0; count && mPendingMask && j < numSensors; j++) {				if(mPendingMask & (1<<j)) {					mPendingMask &= ~(1<<j);					mPendingEvents[j].timestamp = time;					if(mEnabled & (1<<j)) {						*data++ = mPendingEvents[j];						count--;						numEventReceived++;					}				}			}			if(!mPendingMask) {				mInputReader.next();			}		} else {			LOGE("Accelerometer: unknown event(type=%d, code=%d)",					type, event->code);			mInputReader.next();		}	}		return numEventReceived;}

int PressureSensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_REL) {            if (event->code == EVENT_TYPE_PRESSURE) {                mPendingEvent.pressure = event->value * PRESSURE_HECTO;            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            ALOGE("%s: unknown event (type=%d, code=%d)", LOGTAG,                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int ProximitySensor::readEvents(sensors_event_t* data, int count){    if (count < 1)        return -EINVAL;    if (mHasPendingEvent) {        mHasPendingEvent = false;        mPendingEvent.timestamp = getTimestamp();        *data = mPendingEvent;        return mEnabled ? 1 : 0;    }    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if (type == EV_ABS) {            if (event->code == EVENT_TYPE_PROXIMITY) {                mPendingEvent.distance = indexToValue(event->value);            }        } else if (type == EV_SYN) {            mPendingEvent.timestamp = timevalToNano(event->time);            if (mEnabled) {                *data++ = mPendingEvent;                count--;                numEventReceived++;            }        } else {            LOGE("ProximitySensor: unknown event (type=%d, code=%d)",                    type, event->code);        }        mInputReader.next();    }    return numEventReceived;}

int PressSensor::readEvents(sensors_event_t* data, int count){	int i;    if (count < 1)        return -EINVAL;    ssize_t n = mInputReader.fill(data_fd);    if (n < 0)        return n;    int numEventReceived = 0;    input_event const* event;    while (count && mInputReader.readEvent(&event)) {        int type = event->type;        if ((type == EV_ABS) || (type == EV_REL) || (type == EV_KEY)) {            processEvent(event->code, event->value);            mInputReader.next();        } else if (type == EV_SYN) {            int64_t time = timevalToNano(event->time);			for(i = 0 ; i< sensors && mPendingMask && count ;i++){			  	 	if(mPendingMask & (1 << i)){						mPendingMask &= ~(1 << i);						mPendingEvent[i].timestamp = time;						if (mEnabled[i]) {							*data++ = mPendingEvent[i];							count--;							numEventReceived++;						}			  	 	}	       }		   if (!mPendingMask) {		       mInputReader.next();		   }        } else {            mInputReader.next();        }    }    return numEventReceived;}