Merge changes from topic "background_sensors_revert" into rvc-dev

* changes:
  Revert "Disable sensors when an app goes to background"
  Revert "Extend background app behavior for direct channel"
  Revert "Fail on flush if no sensors are found"
  Revert "Fix deadlock on SensorService"

5 files changed, 45 insertions, 182 deletions

diff --git a/services/sensorservice/SensorDirectConnection.cpp b/services/sensorservice/SensorDirectConnection.cpp
index 1622e7753e..106efd6634 100644
--- a/services/sensorservice/SensorDirectConnection.cpp
+++ b/services/sensorservice/SensorDirectConnection.cpp
@@ -93,23 +93,6 @@ sp<BitTube> SensorService::SensorDirectConnection::getSensorChannel() const {
     return nullptr;
 }
 
-void SensorService::SensorDirectConnection::updateSensorSubscriptions() {
-    if (!hasSensorAccess()) {
-        stopAll(true /* backupRecord */);
-    } else {
-        recoverAll();
-    }
-}
-
-void SensorService::SensorDirectConnection::setSensorAccess(bool hasAccess) {
-    mHasSensorAccess = hasAccess;
-    updateSensorSubscriptions();
-}
-
-bool SensorService::SensorDirectConnection::hasSensorAccess() const {
-    return mHasSensorAccess && !mService->mSensorPrivacyPolicy->isSensorPrivacyEnabled();
-}
-
 status_t SensorService::SensorDirectConnection::enableDisable(
         int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
         int reservedFlags) {
diff --git a/services/sensorservice/SensorDirectConnection.h b/services/sensorservice/SensorDirectConnection.h
index fa88fbc360..ead08d3fb6 100644
--- a/services/sensorservice/SensorDirectConnection.h
+++ b/services/sensorservice/SensorDirectConnection.h
@@ -54,9 +54,6 @@ public:
     // called by SensorService when return to NORMAL mode.
     void recoverAll();
 
-    void updateSensorSubscriptions();
-
-    void setSensorAccess(bool hasAccess);
 protected:
     virtual ~SensorDirectConnection();
     // ISensorEventConnection functions
@@ -69,7 +66,6 @@ protected:
     virtual int32_t configureChannel(int handle, int rateLevel);
     virtual void destroy();
 private:
-    bool hasSensorAccess() const;
     const sp<SensorService> mService;
     const uid_t mUid;
     const sensors_direct_mem_t mMem;
@@ -80,8 +76,6 @@ private:
     std::unordered_map<int, int> mActivated;
     std::unordered_map<int, int> mActivatedBackup;
 
-    std::atomic_bool mHasSensorAccess = true;
-
     mutable Mutex mDestroyLock;
     bool mDestroyed;
 };
diff --git a/services/sensorservice/SensorEventConnection.cpp b/services/sensorservice/SensorEventConnection.cpp
index 5be4ccde1f..e79937295b 100644
--- a/services/sensorservice/SensorEventConnection.cpp
+++ b/services/sensorservice/SensorEventConnection.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <cinttypes>
 #include <sys/socket.h>
 #include <utils/threads.h>
 
@@ -70,16 +69,17 @@ void SensorService::SensorEventConnection::onFirstRef() {
 }
 
 bool SensorService::SensorEventConnection::needsWakeLock() {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     return !mDead && mWakeLockRefCount > 0;
 }
 
 void SensorService::SensorEventConnection::resetWakeLockRefCount() {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     mWakeLockRefCount = 0;
 }
 
 void SensorService::SensorEventConnection::dump(String8& result) {
+    Mutex::Autolock _l(mConnectionLock);
     result.appendFormat("\tOperating Mode: ");
     if (!mService->isWhiteListedPackage(getPackageName())) {
         result.append("RESTRICTED\n");
@@ -91,10 +91,8 @@ void SensorService::SensorEventConnection::dump(String8& result) {
     result.appendFormat("\t %s | WakeLockRefCount %d | uid %d | cache size %d | "
             "max cache size %d\n", mPackageName.string(), mWakeLockRefCount, mUid, mCacheSize,
             mMaxCacheSize);
-
-    std::lock_guard<std::mutex> _l(mConnectionLock);
     for (auto& it : mSensorInfo) {
-        const FlushInfo& flushInfo = it.second.flushInfo;
+        const FlushInfo& flushInfo = it.second;
         result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d \n",
                             mService->getSensorName(it.first).string(),
                             it.first,
@@ -123,7 +121,7 @@ void SensorService::SensorEventConnection::dump(String8& result) {
  */
 void SensorService::SensorEventConnection::dump(util::ProtoOutputStream* proto) const {
     using namespace service::SensorEventConnectionProto;
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
 
     if (!mService->isWhiteListedPackage(getPackageName())) {
         proto->write(OPERATING_MODE, OP_MODE_RESTRICTED);
@@ -138,7 +136,7 @@ void SensorService::SensorEventConnection::dump(util::ProtoOutputStream* proto)
     proto->write(CACHE_SIZE, int32_t(mCacheSize));
     proto->write(MAX_CACHE_SIZE, int32_t(mMaxCacheSize));
     for (auto& it : mSensorInfo) {
-        const FlushInfo& flushInfo = it.second.flushInfo;
+        const FlushInfo& flushInfo = it.second;
         const uint64_t token = proto->start(FLUSH_INFOS);
         proto->write(FlushInfoProto::SENSOR_NAME,
                 std::string(mService->getSensorName(it.first)));
@@ -159,33 +157,28 @@ void SensorService::SensorEventConnection::dump(util::ProtoOutputStream* proto)
 #endif
 }
 
-bool SensorService::SensorEventConnection::addSensor(
-    int32_t handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags) {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
+    Mutex::Autolock _l(mConnectionLock);
     sp<SensorInterface> si = mService->getSensorInterfaceFromHandle(handle);
     if (si == nullptr ||
         !canAccessSensor(si->getSensor(), "Tried adding", mOpPackageName) ||
         mSensorInfo.count(handle) > 0) {
         return false;
     }
-
-    SensorRequest request = {
-      .samplingPeriodNs = samplingPeriodNs,
-      .maxBatchReportLatencyNs = maxBatchReportLatencyNs,
-      .reservedFlags = reservedFlags
-    };
-
-    mSensorInfo[handle] = request;
+    mSensorInfo[handle] = FlushInfo();
     return true;
 }
 
 bool SensorService::SensorEventConnection::removeSensor(int32_t handle) {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
-    return mSensorInfo.erase(handle) > 0;
+    Mutex::Autolock _l(mConnectionLock);
+    if (mSensorInfo.erase(handle) >= 0) {
+        return true;
+    }
+    return false;
 }
 
 std::vector<int32_t> SensorService::SensorEventConnection::getActiveSensorHandles() const {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     std::vector<int32_t> list;
     for (auto& it : mSensorInfo) {
         list.push_back(it.first);
@@ -194,19 +187,17 @@ std::vector<int32_t> SensorService::SensorEventConnection::getActiveSensorHandle
 }
 
 bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const {
-    std::lock_guard<std::recursive_mutex> _backlock(mBackupLock);
-    std::lock_guard<std::mutex> _lock(mConnectionLock);
-    return mSensorInfo.count(handle) + mSensorInfoBackup.count(handle) > 0;
+    Mutex::Autolock _l(mConnectionLock);
+    return mSensorInfo.count(handle) > 0;
 }
 
 bool SensorService::SensorEventConnection::hasAnySensor() const {
-    std::lock_guard<std::recursive_mutex> _backlock(mBackupLock);
-    std::lock_guard<std::mutex> _lock(mConnectionLock);
-    return mSensorInfo.size() + mSensorInfoBackup.size() ? true : false;
+    Mutex::Autolock _l(mConnectionLock);
+    return mSensorInfo.size() ? true : false;
 }
 
 bool SensorService::SensorEventConnection::hasOneShotSensors() const {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     for (auto &it : mSensorInfo) {
         const int handle = it.first;
         sp<SensorInterface> si = mService->getSensorInterfaceFromHandle(handle);
@@ -223,15 +214,15 @@ String8 SensorService::SensorEventConnection::getPackageName() const {
 
 void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
                                 bool value) {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     if (mSensorInfo.count(handle) > 0) {
-        FlushInfo& flushInfo = mSensorInfo[handle].flushInfo;
+        FlushInfo& flushInfo = mSensorInfo[handle];
         flushInfo.mFirstFlushPending = value;
     }
 }
 
 void SensorService::SensorEventConnection::updateLooperRegistration(const sp<Looper>& looper) {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     updateLooperRegistrationLocked(looper);
 }
 
@@ -282,9 +273,9 @@ void SensorService::SensorEventConnection::updateLooperRegistrationLocked(
 }
 
 void SensorService::SensorEventConnection::incrementPendingFlushCount(int32_t handle) {
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     if (mSensorInfo.count(handle) > 0) {
-        FlushInfo& flushInfo = mSensorInfo[handle].flushInfo;
+        FlushInfo& flushInfo = mSensorInfo[handle];
         flushInfo.mPendingFlushEventsToSend++;
     }
 }
@@ -298,7 +289,7 @@ status_t SensorService::SensorEventConnection::sendEvents(
     std::unique_ptr<sensors_event_t[]> sanitizedBuffer;
 
     int count = 0;
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     if (scratch) {
         size_t i=0;
         while (i<numEvents) {
@@ -319,7 +310,7 @@ status_t SensorService::SensorEventConnection::sendEvents(
                 continue;
             }
 
-            FlushInfo& flushInfo = mSensorInfo[sensor_handle].flushInfo;
+            FlushInfo& flushInfo = mSensorInfo[sensor_handle];
             // Check if there is a pending flush_complete event for this sensor on this connection.
             if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true &&
                     mapFlushEventsToConnections[i] == this) {
@@ -440,62 +431,9 @@ status_t SensorService::SensorEventConnection::sendEvents(
     return size < 0 ? status_t(size) : status_t(NO_ERROR);
 }
 
-void SensorService::SensorEventConnection::updateSensorSubscriptions() {
-    if (!hasSensorAccess()) {
-        stopAll();
-    } else {
-        recoverAll();
-    }
-}
-
 void SensorService::SensorEventConnection::setSensorAccess(const bool hasAccess) {
-    if (mHasSensorAccess != hasAccess) {
-        mHasSensorAccess = hasAccess;
-        updateSensorSubscriptions();
-    }
-}
-
-void SensorService::SensorEventConnection::stopAll() {
-    bool backupPerformed = false;
-    std::lock_guard<std::recursive_mutex> _backlock(mBackupLock);
-    {
-        std::lock_guard<std::mutex> _lock(mConnectionLock);
-        if (!mSensorInfo.empty()) {
-            mSensorInfoBackup = mSensorInfo;
-            mSensorInfo.clear();
-            backupPerformed = true;
-        }
-    }
-
-    if (backupPerformed) {
-        for (auto& it : mSensorInfoBackup) {
-            int32_t handle = it.first;
-
-            status_t err =  mService->disable(this, handle);
-
-            if (err != NO_ERROR) {
-                ALOGE("Error disabling sensor %d", handle);
-            }
-        }
-    }
-}
-
-void SensorService::SensorEventConnection::recoverAll() {
-    std::lock_guard<std::recursive_mutex> _l(mBackupLock);
-    for (auto& it : mSensorInfoBackup) {
-        int32_t handle = it.first;
-        SensorRequest &request = it.second;
-
-        status_t err =  mService->enable(
-            this, handle, request.samplingPeriodNs, request.maxBatchReportLatencyNs,
-            request.reservedFlags, mOpPackageName);
-
-        if (err != NO_ERROR) {
-            ALOGE("Error recovering sensor %d", handle);
-        }
-    }
-
-    mSensorInfoBackup.clear();
+    Mutex::Autolock _l(mConnectionLock);
+    mHasSensorAccess = hasAccess;
 }
 
 bool SensorService::SensorEventConnection::hasSensorAccess() {
@@ -597,7 +535,7 @@ void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() {
             continue;
         }
 
-        FlushInfo& flushInfo = it.second.flushInfo;
+        FlushInfo& flushInfo = it.second;
         while (flushInfo.mPendingFlushEventsToSend > 0) {
             flushCompleteEvent.meta_data.sensor = handle;
             bool wakeUpSensor = si->getSensor().isWakeUpSensor();
@@ -622,7 +560,7 @@ void SensorService::SensorEventConnection::writeToSocketFromCache() {
     // half the size of the socket buffer allocated in BitTube whichever is smaller.
     const int maxWriteSize = helpers::min(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2,
             int(mService->mSocketBufferSize/(sizeof(sensors_event_t)*2)));
-    std::lock_guard<std::mutex> _l(mConnectionLock);
+    Mutex::Autolock _l(mConnectionLock);
     // Send pending flush complete events (if any)
     sendPendingFlushEventsLocked();
     for (int numEventsSent = 0; numEventsSent < mCacheSize;) {
@@ -689,7 +627,7 @@ void SensorService::SensorEventConnection::countFlushCompleteEventsLocked(
                 continue;
             }
 
-            FlushInfo& flushInfo = mSensorInfo[scratch[j].meta_data.sensor].flushInfo;
+            FlushInfo& flushInfo = mSensorInfo[scratch[j].meta_data.sensor];
             flushInfo.mPendingFlushEventsToSend++;
             ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d",
                      flushInfo.mPendingFlushEventsToSend);
@@ -725,21 +663,13 @@ status_t SensorService::SensorEventConnection::enableDisable(
     } else {
         err = mService->disable(this, handle);
     }
-
     return err;
 }
 
 status_t SensorService::SensorEventConnection::setEventRate(
         int handle, nsecs_t samplingPeriodNs)
 {
-    status_t err = mService->setEventRate(this, handle, samplingPeriodNs, mOpPackageName);
-
-    std::lock_guard<std::mutex> _l(mConnectionLock);
-    if (err == NO_ERROR && mSensorInfo.count(handle) > 0) {
-        mSensorInfo[handle].samplingPeriodNs = samplingPeriodNs;
-    }
-
-    return err;
+    return mService->setEventRate(this, handle, samplingPeriodNs, mOpPackageName);
 }
 
 status_t  SensorService::SensorEventConnection::flush() {
@@ -760,7 +690,7 @@ int SensorService::SensorEventConnection::handleEvent(int fd, int events, void*
             // and remove the fd from Looper. Call checkWakeLockState to know if SensorService
             // can release the wake-lock.
             ALOGD_IF(DEBUG_CONNECTIONS, "%p Looper error %d", this, fd);
-            std::lock_guard<std::mutex> _l(mConnectionLock);
+            Mutex::Autolock _l(mConnectionLock);
             mDead = true;
             mWakeLockRefCount = 0;
             updateLooperRegistrationLocked(mService->getLooper());
@@ -779,7 +709,7 @@ int SensorService::SensorEventConnection::handleEvent(int fd, int events, void*
         unsigned char buf[sizeof(sensors_event_t)];
         ssize_t numBytesRead = ::recv(fd, buf, sizeof(buf), MSG_DONTWAIT);
         {
-            std::lock_guard<std::mutex> _l(mConnectionLock);
+            Mutex::Autolock _l(mConnectionLock);
             if (numBytesRead == sizeof(sensors_event_t)) {
                 if (!mDataInjectionMode) {
                     ALOGE("Data injected in normal mode, dropping event"
diff --git a/services/sensorservice/SensorEventConnection.h b/services/sensorservice/SensorEventConnection.h
index 80e743171a..1ca35c02cf 100644
--- a/services/sensorservice/SensorEventConnection.h
+++ b/services/sensorservice/SensorEventConnection.h
@@ -57,8 +57,7 @@ public:
     bool hasSensor(int32_t handle) const;
     bool hasAnySensor() const;
     bool hasOneShotSensors() const;
-    bool addSensor(
-        int32_t handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags);
+    bool addSensor(int32_t handle);
     bool removeSensor(int32_t handle);
     std::vector<int32_t> getActiveSensorHandles() const;
     void setFirstFlushPending(int32_t handle, bool value);
@@ -71,7 +70,7 @@ public:
     uid_t getUid() const { return mUid; }
 
     void setSensorAccess(const bool hasAccess);
-    void updateSensorSubscriptions();
+
 private:
     virtual ~SensorEventConnection();
     virtual void onFirstRef();
@@ -137,22 +136,13 @@ private:
     // privacy not being enabled.
     bool hasSensorAccess();
 
-    void stopAll();
-    void recoverAll();
-
     // Call noteOp for the sensor if the sensor requires a permission
     bool noteOpIfRequired(const sensors_event_t& event);
 
     sp<SensorService> const mService;
     sp<BitTube> mChannel;
     uid_t mUid;
-
-    // A lock that should be used when modifying mSensorInfo
-    mutable std::mutex mConnectionLock;
-
-    // A lock that should be used when modifying mSensorInfoBackup
-    mutable std::recursive_mutex mBackupLock;
-
+    mutable Mutex mConnectionLock;
     // Number of events from wake up sensors which are still pending and haven't been delivered to
     // the corresponding application. It is incremented by one unit for each write to the socket.
     uint32_t mWakeLockRefCount;
@@ -179,17 +169,8 @@ private:
 
         FlushInfo() : mPendingFlushEventsToSend(0), mFirstFlushPending(false) {}
     };
-
-    struct SensorRequest {
-      nsecs_t samplingPeriodNs;
-      nsecs_t maxBatchReportLatencyNs;
-      int reservedFlags;
-      FlushInfo flushInfo;
-    };
-
     // protected by SensorService::mLock. Key for this map is the sensor handle.
-    std::unordered_map<int32_t, SensorRequest> mSensorInfo;
-    std::unordered_map<int32_t, SensorRequest> mSensorInfoBackup;
+    std::unordered_map<int32_t, FlushInfo> mSensorInfo;
 
     sensors_event_t *mEventCache;
     int mCacheSize, mMaxCacheSize;
@@ -204,7 +185,7 @@ private:
 
     mutable Mutex mDestroyLock;
     bool mDestroyed;
-    std::atomic_bool mHasSensorAccess;
+    bool mHasSensorAccess;
 
     // Store a mapping of sensor handles to required AppOp for a sensor. This map only contains a
     // valid mapping for sensors that require a permission in order to reduce the lookup time.
diff --git a/services/sensorservice/SensorService.cpp b/services/sensorservice/SensorService.cpp
index 29df82582f..5fdc74fb8c 100644
--- a/services/sensorservice/SensorService.cpp
+++ b/services/sensorservice/SensorService.cpp
@@ -301,24 +301,11 @@ void SensorService::onFirstRef() {
 
 void SensorService::setSensorAccess(uid_t uid, bool hasAccess) {
     ConnectionSafeAutolock connLock = mConnectionHolder.lock(mLock);
-    const auto& connections = connLock.getActiveConnections();
-    const auto& directConnections = connLock.getDirectConnections();
-
-    mLock.unlock();
-    for (const sp<SensorEventConnection>& conn : connections) {
-        if (conn->getUid() == uid) {
-            conn->setSensorAccess(hasAccess);
-        }
-    }
-
-    for (const sp<SensorDirectConnection>& conn : directConnections) {
+    for (const sp<SensorEventConnection>& conn : connLock.getActiveConnections()) {
         if (conn->getUid() == uid) {
             conn->setSensorAccess(hasAccess);
         }
     }
-
-    // Lock the mutex again for clean shutdown
-    mLock.lock();
 }
 
 const Sensor& SensorService::registerSensor(SensorInterface* s, bool isDebug, bool isVirtual) {
@@ -651,11 +638,8 @@ void SensorService::disableAllSensors() {
 
 void SensorService::disableAllSensorsLocked(ConnectionSafeAutolock* connLock) {
     SensorDevice& dev(SensorDevice::getInstance());
-    for (const sp<SensorEventConnection>& connection : connLock->getActiveConnections()) {
-        connection->updateSensorSubscriptions();
-    }
     for (const sp<SensorDirectConnection>& connection : connLock->getDirectConnections()) {
-        connection->updateSensorSubscriptions();
+        connection->stopAll(true /* backupRecord */);
     }
     dev.disableAllSensors();
     // Clear all pending flush connections for all active sensors. If one of the active
@@ -682,11 +666,8 @@ void SensorService::enableAllSensorsLocked(ConnectionSafeAutolock* connLock) {
     }
     SensorDevice& dev(SensorDevice::getInstance());
     dev.enableAllSensors();
-    for (const sp<SensorEventConnection>& connection : connLock->getActiveConnections()) {
-        connection->updateSensorSubscriptions();
-    }
     for (const sp<SensorDirectConnection>& connection : connLock->getDirectConnections()) {
-        connection->updateSensorSubscriptions();
+        connection->recoverAll();
     }
 }
 
@@ -1608,7 +1589,7 @@ status_t SensorService::enable(const sp<SensorEventConnection>& connection,
         }
     }
 
-    if (connection->addSensor(handle, samplingPeriodNs, maxBatchReportLatencyNs, reservedFlags)) {
+    if (connection->addSensor(handle)) {
         BatteryService::enableSensor(connection->getUid(), handle);
         // the sensor was added (which means it wasn't already there)
         // so, see if this connection becomes active
@@ -1758,22 +1739,17 @@ status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
     const int halVersion = dev.getHalDeviceVersion();
     status_t err(NO_ERROR);
     Mutex::Autolock _l(mLock);
-
-    size_t numSensors = 0;
     // Loop through all sensors for this connection and call flush on each of them.
     for (int handle : connection->getActiveSensorHandles()) {
         sp<SensorInterface> sensor = getSensorInterfaceFromHandle(handle);
         if (sensor == nullptr) {
             continue;
         }
-        numSensors++;
-
         if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
             ALOGE("flush called on a one-shot sensor");
             err = INVALID_OPERATION;
             continue;
         }
-
         if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0 || isVirtualSensor(handle)) {
             // For older devices just increment pending flush count which will send a trivial
             // flush complete event.
@@ -1791,8 +1767,7 @@ status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
             err = (err_flush != NO_ERROR) ? err_flush : err;
         }
     }
-
-    return (numSensors == 0) ? INVALID_OPERATION : err;
+    return err;
 }
 
 bool SensorService::canAccessSensor(const Sensor& sensor, const char* operation,