Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bdaf6fe2 authored by Anh Pham's avatar Anh Pham Committed by Android (Google) Code Review
Browse files

Merge changes from topic "remove_resampling" into sc-dev 

* changes:
  Clear calling ID before using SensorPrivacyManager
  Revert "Resample sensor events for non-direct connections."
parents e1bbbe7a b04658bd

services/sensorservice/SensorEventConnection.cpp

+5 −31
Original line number Diff line number Diff line
@@ -287,29 +287,6 @@ bool SensorService::SensorEventConnection::incrementPendingFlushCountIfHasAccess 
    }

}



// TODO(b/179649922): A better algorithm to guarantee that capped connections will get a sampling

// rate close to 200 Hz. With the current algorithm, apps might be punished unfairly: E.g.,two apps

// make requests to the sensor service at the same time, one is not capped and uses 250 Hz, and one

//is capped, the capped connection will only get 125 Hz.

void SensorService::SensorEventConnection::addSensorEventsToBuffer(bool shouldResample,

    const sensors_event_t& sensorEvent, sensors_event_t* buffer, int* index) {

    if (!shouldResample || !mService->isSensorInCappedSet(sensorEvent.type)) {

        buffer[(*index)++] = sensorEvent;

    } else {

        int64_t lastTimestamp = -1;

        auto entry = mSensorLastTimestamp.find(sensorEvent.sensor);

        if (entry != mSensorLastTimestamp.end()) {

            lastTimestamp = entry->second;

        }

        // Allow 10% headroom here because the clocks are not perfect.

        if (lastTimestamp == -1  || sensorEvent.timestamp - lastTimestamp

                                        >= 0.9 * SENSOR_SERVICE_CAPPED_SAMPLING_PERIOD_NS) {

            mSensorLastTimestamp[sensorEvent.sensor] = sensorEvent.timestamp;

            buffer[(*index)++] = sensorEvent;

        }

    }

}



status_t SensorService::SensorEventConnection::sendEvents(

        sensors_event_t const* buffer, size_t numEvents,

        sensors_event_t* scratch,
@@ -318,8 +295,6 @@ status_t SensorService::SensorEventConnection::sendEvents( 


    std::unique_ptr<sensors_event_t[]> sanitizedBuffer;



    bool shouldResample = mService->isMicSensorPrivacyEnabledForUid(mUid) ||

                            mIsRateCappedBasedOnPermission;

    int count = 0;

    Mutex::Autolock _l(mConnectionLock);

    if (scratch) {
@@ -373,7 +348,7 @@ status_t SensorService::SensorEventConnection::sendEvents( 
                    // Regular sensor event, just copy it to the scratch buffer after checking

                    // the AppOp.

                    if (hasSensorAccess() && noteOpIfRequired(buffer[i])) {

                        addSensorEventsToBuffer(shouldResample, buffer[i], scratch, &count);

                        scratch[count++] = buffer[i];

                    }

                }

                i++;
@@ -383,13 +358,12 @@ status_t SensorService::SensorEventConnection::sendEvents( 
                                        buffer[i].meta_data.sensor == sensor_handle)));

        }

    } else {

        sanitizedBuffer.reset(new sensors_event_t[numEvents]);

        scratch = sanitizedBuffer.get();

        if (hasSensorAccess()) {

            for (size_t i = 0; i < numEvents; i++) {

                addSensorEventsToBuffer(shouldResample, buffer[i], scratch, &count);

            }

            scratch = const_cast<sensors_event_t *>(buffer);

            count = numEvents;

        } else {

            sanitizedBuffer.reset(new sensors_event_t[numEvents]);

            scratch = sanitizedBuffer.get();

            for (size_t i = 0; i < numEvents; i++) {

                if (buffer[i].type == SENSOR_TYPE_META_DATA) {

                    scratch[count++] = buffer[i++];

services/sensorservice/SensorEventConnection.h

+0 −6
Original line number Diff line number Diff line
@@ -145,16 +145,10 @@ private: 
    void capRates();

    // Recover sensor connection previously capped by capRates().

    void uncapRates();



    // Add sensorEvent to buffer at position index if the sensorEvent satisfies throttling rules.

    void addSensorEventsToBuffer(bool shouldResample, const sensors_event_t& sensorEvent,

                        sensors_event_t* buffer, int* index);

    sp<SensorService> const mService;

    sp<BitTube> mChannel;

    uid_t mUid;

    std::atomic_bool mIsRateCappedBasedOnPermission;

    // Store a mapping of sensor to the timestamp of their last sensor event.

    std::unordered_map<int, int64_t> mSensorLastTimestamp;

    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.

services/sensorservice/SensorService.cpp

+3 −1
Original line number Diff line number Diff line
@@ -2129,12 +2129,14 @@ status_t SensorService::adjustRateLevelBasedOnMicAndPermission(int* requestedRat 
}



void SensorService::SensorPrivacyPolicy::registerSelf() {

    AutoCallerClear acc;

    SensorPrivacyManager spm;

    mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();

    spm.addSensorPrivacyListener(this);

}



void SensorService::SensorPrivacyPolicy::unregisterSelf() {

    AutoCallerClear acc;

    SensorPrivacyManager spm;

    spm.removeSensorPrivacyListener(this);

}
@@ -2167,7 +2169,7 @@ binder::Status SensorService::SensorPrivacyPolicy::onSensorPrivacyChanged(bool e 


status_t SensorService::SensorPrivacyPolicy::registerSelfForIndividual(int userId) {

    Mutex::Autolock _l(mSensorPrivacyLock);



    AutoCallerClear acc;

    SensorPrivacyManager spm;

    status_t err = spm.addIndividualSensorPrivacyListener(userId,

            SensorPrivacyManager::INDIVIDUAL_SENSOR_MICROPHONE, this);

services/sensorservice/SensorService.h

+16 −0
Original line number Diff line number Diff line
@@ -242,6 +242,22 @@ private: 
            userid_t mUserId;

    };



    // A class automatically clearing and restoring binder caller identity inside

    // a code block (scoped variable).

    // Declare one systematically before calling SensorPrivacyManager methods so that they are

    // executed with the same level of privilege as the SensorService process.

    class AutoCallerClear {

        public:

            AutoCallerClear() :

                mToken(IPCThreadState::self()->clearCallingIdentity()) {}

            ~AutoCallerClear() {

                IPCThreadState::self()->restoreCallingIdentity(mToken);

            }



        private:

            const int64_t mToken;

    };



    enum Mode {

       // The regular operating mode where any application can register/unregister/call flush on

       // sensors.