Sensor: Implement ALS flush function

Add ambient light sensor HAL flush function need by android wear,
add flush event data to event data queue for polling.

Change-Id: Iaa6b8c818f07242dc09bf281445b2e1f4d0231f4
Tracked-On: https://jira01.devtools.intel.com/browse/MARVIN-627
Signed-off-by: Baixing Tan <baixingx.tan@intel.com>
Reviewed-on: https://android.intel.com:443/363333

5 files changed, 89 insertions, 4 deletions

diff --git a/als/AlsSensor.cpp b/als/AlsSensor.cpp
index 61afd66..11837d5 100644
--- a/als/AlsSensor.cpp
+++ b/als/AlsSensor.cpp
@@ -108,6 +108,11 @@ int LightSensor::enable(int32_t /* handle */, int en)
     return 0;
 }
 
+int LightSensor::isActivated(int /* handle */)
+{
+    return mEnabled;
+}
+
 #ifdef HAL_VERSION_GT_1_0
 int LightSensor::batch(int /* handle */, int /* flags */, int64_t period_ns, int64_t /* timeout */)
 {
diff --git a/als/AlsSensor.h b/als/AlsSensor.h
index a393b0b..3bf726f 100644
--- a/als/AlsSensor.h
+++ b/als/AlsSensor.h
@@ -54,6 +54,7 @@ public:
     virtual bool hasPendingEvents() const;
     virtual int setDelay(int32_t handle, int64_t ns);
     virtual int enable(int32_t handle, int enabled);
+    virtual int isActivated(int handle);
 #ifdef HAL_VERSION_GT_1_0
     virtual int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
 #endif
diff --git a/als/SensorBase.cpp b/als/SensorBase.cpp
index 5cdf7cf..d8cfc43 100644
--- a/als/SensorBase.cpp
+++ b/als/SensorBase.cpp
@@ -144,6 +144,12 @@ int SensorBase::enable(int32_t /* handle */, int /* enabled */)
     return 0;
 }
 
+int SensorBase::isActivated(int /* handle */)
+{
+    FUNC_LOG;
+    return 0;
+}
+
 #ifdef HAL_VERSION_GT_1_0
 int SensorBase::batch(int /* handle */, int /* flags */, int64_t /* period_ns */, int64_t /* timeout */)
 {
diff --git a/als/SensorBase.h b/als/SensorBase.h
index 2eaa872..417ba20 100644
--- a/als/SensorBase.h
+++ b/als/SensorBase.h
@@ -91,6 +91,7 @@ public:
     virtual int getFd() const;
     virtual int setDelay(int32_t handle, int64_t ns);
     virtual int enable(int32_t handle, int enabled);
+    virtual int isActivated(int handle);
 #ifdef HAL_VERSION_GT_1_0
     virtual int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
 #endif
diff --git a/als/sensors.cpp b/als/sensors.cpp
index 513e5e8..04d349d 100644
--- a/als/sensors.cpp
+++ b/als/sensors.cpp
@@ -90,6 +90,7 @@ struct sensors_poll_context_t {
     int setDelay(int handle, int64_t ns);
 #ifdef HAL_VERSION_GT_1_0
     int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
+    int flush(int handle);
 #endif
     int pollEvents(sensors_event_t* data, int count);
     bool getInitialized() { return mInitialized; };
@@ -99,14 +100,16 @@ private:
 
     enum {
         light = 0,
-        numSensorDrivers,       // wake pipe goes here
+        numSensorDrivers,       /* wake pipe goes here */
+        flushPipe,              /* flush pipe goes here */
         numFds,
     };
 
-    static const size_t wake = numFds - 1;
+    static const size_t wake = numFds - 2;
     static const char WAKE_MESSAGE = 'W';
     struct pollfd mPollFds[numFds];
     int mWritePipeFd;
+    int mFlushWritePipeFd;
     SensorBase* mSensors[numSensorDrivers];
 
     int handleToDriver(int handle) const {
@@ -135,13 +138,28 @@ sensors_poll_context_t::sensors_poll_context_t()
     int wakeFds[2];
     int result = pipe(wakeFds);
     ALOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));
-    fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);
-    fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);
+    result = fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);
+    ALOGE_IF(result<0, "error setting wakeFds[0] access mode (%s)", strerror(errno));
+    result = fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);
+    ALOGE_IF(result<0, "error setting wakeFds[1] access mode (%s)", strerror(errno));
     mWritePipeFd = wakeFds[1];
 
     mPollFds[wake].fd = wakeFds[0];
     mPollFds[wake].events = POLLIN;
     mPollFds[wake].revents = 0;
+
+    int flushFds[2];
+    result = pipe(flushFds);
+    ALOGE_IF(result<0, "error creating flush pipe (%s)", strerror(errno));
+    result = fcntl(flushFds[0], F_SETFL, O_NONBLOCK);
+    ALOGE_IF(result<0, "error setting flushFds[0] access mode (%s)", strerror(errno));
+    result = fcntl(flushFds[1], F_SETFL, O_NONBLOCK);
+    ALOGE_IF(result<0, "error setting flushFds[1] access mode (%s)", strerror(errno));
+    mFlushWritePipeFd = flushFds[1];
+
+    mPollFds[flushPipe].fd = flushFds[0];
+    mPollFds[flushPipe].events = POLLIN;
+    mPollFds[flushPipe].revents = 0;
     mInitialized = true;
 }
 
@@ -153,6 +171,8 @@ sensors_poll_context_t::~sensors_poll_context_t()
     }
     close(mPollFds[wake].fd);
     close(mWritePipeFd);
+    close(mPollFds[flushPipe].fd);
+    close(mFlushWritePipeFd);
     mInitialized = false;
 }
 
@@ -187,6 +207,32 @@ int sensors_poll_context_t::batch(int handle, int flags, int64_t period_ns, int6
     if (index < 0) return index;
     return mSensors[index]->batch(handle, flags, period_ns, timeout);
 }
+
+int sensors_poll_context_t::flush(int handle)
+{
+    FUNC_LOG;
+    int result;
+    sensors_event_t flush_event_data;
+
+    int index = handleToDriver(handle);
+    if (index < 0) return index;
+
+    result = mSensors[index]->isActivated(handle);
+    if (!result)
+        return -EINVAL;
+
+    flush_event_data.sensor = 0;
+    flush_event_data.timestamp = 0;
+    flush_event_data.meta_data.sensor = handle;
+    flush_event_data.meta_data.what = META_DATA_FLUSH_COMPLETE;
+    flush_event_data.type = SENSOR_TYPE_META_DATA;
+    flush_event_data.version = META_DATA_VERSION;
+
+    result = write(mFlushWritePipeFd, &flush_event_data, sizeof(sensors_event_t));
+    ALOGE_IF(result<0, "error sending flush event data (%s)", strerror(errno));
+
+    return (result >= 0 ? 0 : result);
+}
 #endif
 
 int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)
@@ -208,7 +254,25 @@ int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)
                 data += nb;
             }
         }
+
+        /* flush event data */
         if (count) {
+            if (mPollFds[flushPipe].revents & POLLIN) {
+                int nb = read(mPollFds[flushPipe].fd, data, count * sizeof(sensors_event_t));
+                if (nb < 0) {
+                    ALOGE("error reading from flush pipe (%s)", strerror(errno));
+                    return -errno;
+                }
+                nb = nb/sizeof(sensors_event_t);
+                mPollFds[flushPipe].revents = 0;
+                count -= nb;
+                nbEvents += nb;
+                data += nb;
+            }
+        }
+
+        if (count) {
+            ALOGV("%s: start poll syscall to kernel", __func__);
             n = poll(mPollFds, numFds, nbEvents ? 0 : -1);
             if (n < 0) {
                 ALOGE("poll() failed (%s)", strerror(errno));
@@ -263,6 +327,13 @@ static int poll__batch(struct sensors_poll_device_1 *dev,
     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
     return ctx->batch(handle, flags, period_ns, timeout);
 }
+
+static int poll_flush(struct sensors_poll_device_1 *dev, int handle)
+{
+    FUNC_LOG;
+    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
+    return ctx->flush(handle);
+}
 #endif
 
 static int poll__poll(struct sensors_poll_device_t *dev,
@@ -307,6 +378,7 @@ static int open_sensors(const struct hw_module_t* module, const char* id,
     dev->device.setDelay        = poll__setDelay;
 #ifdef HAL_VERSION_GT_1_0
     dev->device.batch           = poll__batch;
+    dev->device.flush           = poll_flush;
 #endif
     dev->device.poll            = poll__poll;