am e225f6fd: Merge "SensorService fixes." into lmp-dev

* commit 'e225f6fd4a3f17c2705f1d69b176db475a3cc821':
  SensorService fixes.

2 files changed, 33 insertions, 28 deletions

diff --git a/services/sensorservice/SensorService.cpp b/services/sensorservice/SensorService.cpp
index b0695ba..f953a96 100644
--- a/services/sensorservice/SensorService.cpp
+++ b/services/sensorservice/SensorService.cpp
@@ -1002,32 +1002,27 @@ bool SensorService::SensorEventConnection::needsWakeLock() {
 
 void SensorService::SensorEventConnection::dump(String8& result) {
     Mutex::Autolock _l(mConnectionLock);
-    result.appendFormat("\t %d WakeLockRefCount \n", mWakeLockRefCount);
+    result.appendFormat("\t WakeLockRefCount %d | uid %d | cache size %d | max cache size %d\n",
+            mWakeLockRefCount, mUid, mCacheSize, mMaxCacheSize);
     for (size_t i = 0; i < mSensorInfo.size(); ++i) {
         const FlushInfo& flushInfo = mSensorInfo.valueAt(i);
-        result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d | uid %d|"
-                            "cache size: %d max cache size %d\n",
+        result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n",
                             mService->getSensorName(mSensorInfo.keyAt(i)).string(),
                             mSensorInfo.keyAt(i),
                             flushInfo.mFirstFlushPending ? "First flush pending" :
                                                            "active",
-                            flushInfo.mPendingFlushEventsToSend,
-                            mUid,
-                            mCacheSize,
-                            mMaxCacheSize);
+                            flushInfo.mPendingFlushEventsToSend);
+    }
 #if DEBUG_CONNECTIONS
-        result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |"
-                                  " total_acks_needed %d | total_acks_recvd %d\n",
-                                        mEventsReceived,
-                                        mEventsSent,
-                                        mEventsSentFromCache,
-                                        mEventsReceived - (mEventsSentFromCache +
-                                                           mEventsSent + mCacheSize),
-                                        mTotalAcksNeeded,
-                                        mTotalAcksReceived);
+    result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |"
+            " total_acks_needed %d | total_acks_recvd %d\n",
+            mEventsReceived,
+            mEventsSent,
+            mEventsSentFromCache,
+            mEventsReceived - (mEventsSentFromCache + mEventsSent + mCacheSize),
+            mTotalAcksNeeded,
+            mTotalAcksReceived);
 #endif
-
-    }
 }
 
 bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
@@ -1082,7 +1077,7 @@ void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
 }
 
 status_t SensorService::SensorEventConnection::sendEvents(
-        sensors_event_t* buffer, size_t numEvents,
+        sensors_event_t const* buffer, size_t numEvents,
         sensors_event_t* scratch,
         SensorEventConnection const * const * mapFlushEventsToConnections) {
     // filter out events not for this connection
@@ -1207,7 +1202,9 @@ status_t SensorService::SensorEventConnection::sendEvents(
         if (index_wake_up_event >= 0) {
             // If there was a wake_up sensor_event, reset the flag.
             scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
-            --mWakeLockRefCount;
+            if (mWakeLockRefCount > 0) {
+                --mWakeLockRefCount;
+            }
 #if DEBUG_CONNECTIONS
             --mTotalAcksNeeded;
 #endif
@@ -1256,14 +1253,18 @@ void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t
 
 void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() {
     ASensorEvent flushCompleteEvent;
+    memset(&flushCompleteEvent, 0, sizeof(flushCompleteEvent));
     flushCompleteEvent.type = SENSOR_TYPE_META_DATA;
-    flushCompleteEvent.sensor = 0;
     // Loop through all the sensors for this connection and check if there are any pending
     // flush complete events to be sent.
     for (size_t i = 0; i < mSensorInfo.size(); ++i) {
         FlushInfo& flushInfo = mSensorInfo.editValueAt(i);
         while (flushInfo.mPendingFlushEventsToSend > 0) {
-            flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i);
+            const int sensor_handle = mSensorInfo.keyAt(i);
+            flushCompleteEvent.meta_data.sensor = sensor_handle;
+            if (mService->getSensorFromHandle(sensor_handle).isWakeUpSensor()) {
+               flushCompleteEvent.flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
+            }
             ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1);
             if (size < 0) {
                 return;
@@ -1303,7 +1304,9 @@ void SensorService::SensorEventConnection::writeToSocketFromCacheLocked() {
                 // If there was a wake_up sensor_event, reset the flag.
                 mEventCache[index_wake_up_event + numEventsSent].flags  &=
                         ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
-                --mWakeLockRefCount;
+                if (mWakeLockRefCount > 0) {
+                    --mWakeLockRefCount;
+                }
 #if DEBUG_CONNECTIONS
                 --mTotalAcksNeeded;
 #endif
@@ -1328,7 +1331,7 @@ void SensorService::SensorEventConnection::writeToSocketFromCacheLocked() {
 }
 
 void SensorService::SensorEventConnection::countFlushCompleteEventsLocked(
-                sensors_event_t* scratch, const int numEventsDropped) {
+                sensors_event_t const* scratch, const int numEventsDropped) {
     ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped);
     // Count flushComplete events in the events that are about to the dropped. These will be sent
     // separately before the next batch of events.
@@ -1394,7 +1397,9 @@ int SensorService::SensorEventConnection::handleEvent(int fd, int events, void*
 
         {
            Mutex::Autolock _l(mConnectionLock);
-           --mWakeLockRefCount;
+           if (mWakeLockRefCount > 0) {
+               --mWakeLockRefCount;
+           }
 #if DEBUG_CONNECTIONS
            ++mTotalAcksReceived;
 #endif
diff --git a/services/sensorservice/SensorService.h b/services/sensorservice/SensorService.h
index 9654f65..0fcafac 100644
--- a/services/sensorservice/SensorService.h
+++ b/services/sensorservice/SensorService.h
@@ -86,7 +86,7 @@ class SensorService :
         // Count the number of flush complete events which are about to be dropped in the buffer.
         // Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be
         // sent separately before the next batch of events.
-        void countFlushCompleteEventsLocked(sensors_event_t* scratch, int numEventsDropped);
+        void countFlushCompleteEventsLocked(sensors_event_t const* scratch, int numEventsDropped);
 
         // Check if there are any wake up events in the buffer. If yes, return the index of the
         // first wake_up sensor event in the buffer else return -1. This wake_up sensor event will
@@ -148,7 +148,7 @@ class SensorService :
     public:
         SensorEventConnection(const sp<SensorService>& service, uid_t uid);
 
-        status_t sendEvents(sensors_event_t* buffer, size_t count,
+        status_t sendEvents(sensors_event_t const* buffer, size_t count,
                 sensors_event_t* scratch,
                 SensorEventConnection const * const * mapFlushEventsToConnections = NULL);
         bool hasSensor(int32_t handle) const;
@@ -190,7 +190,7 @@ class SensorService :
     bool isVirtualSensor(int handle) const;
     Sensor getSensorFromHandle(int handle) const;
     bool isWakeUpSensor(int type) const;
-    void recordLastValueLocked(const sensors_event_t* buffer, size_t count);
+    void recordLastValueLocked(sensors_event_t const* buffer, size_t count);
     static void sortEventBuffer(sensors_event_t* buffer, size_t count);
     Sensor registerSensor(SensorInterface* sensor);
     Sensor registerVirtualSensor(SensorInterface* sensor);