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

Commit 4949c503 authored by Aravind Akella's avatar Aravind Akella
Browse files

Support restricted mode in SensorService. 

In restricted mode, only CTS tests can register for sensors or call flush() on them. The requests
from other applications will be ignored.

Change-Id: Ieb923df3e0cfe3390fe2d052af776da79589744b
parent 5b20fd08

include/gui/ISensorServer.h

+2 −1
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ namespace android { 


class Sensor;

class ISensorEventConnection;

class String8;



class ISensorServer : public IInterface

{
@@ -37,7 +38,7 @@ public: 
    DECLARE_META_INTERFACE(SensorServer);



    virtual Vector<Sensor> getSensorList() = 0;

    virtual sp<ISensorEventConnection> createSensorEventConnection() = 0;

    virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName) = 0;

};



// ----------------------------------------------------------------------------

include/gui/SensorManager.h

+2 −2
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ namespace android { 
class ISensorServer;

class Sensor;

class SensorEventQueue;



class String8;

// ----------------------------------------------------------------------------



class SensorManager :
@@ -53,7 +53,7 @@ public: 


    ssize_t getSensorList(Sensor const* const** list) const;

    Sensor const* getDefaultSensor(int type);

    sp<SensorEventQueue> createEventQueue();

    sp<SensorEventQueue> createEventQueue(String8 packageName = String8(""));



private:

    // DeathRecipient interface

libs/gui/ISensorServer.cpp

+4 −2
Original line number Diff line number Diff line
@@ -63,10 +63,11 @@ public: 
        return v;

    }



    virtual sp<ISensorEventConnection> createSensorEventConnection()

    virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName)

    {

        Parcel data, reply;

        data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());

        data.writeString8(packageName);

        remote()->transact(CREATE_SENSOR_EVENT_CONNECTION, data, &reply);

        return interface_cast<ISensorEventConnection>(reply.readStrongBinder());

    }
@@ -96,7 +97,8 @@ status_t BnSensorServer::onTransact( 
        }

        case CREATE_SENSOR_EVENT_CONNECTION: {

            CHECK_INTERFACE(ISensorServer, data, reply);

            sp<ISensorEventConnection> connection(createSensorEventConnection());

            String8 packageName = data.readString8();

            sp<ISensorEventConnection> connection(createSensorEventConnection(packageName));

            reply->writeStrongBinder(IInterface::asBinder(connection));

            return NO_ERROR;

        }

libs/gui/SensorManager.cpp

+2 −2
Original line number Diff line number Diff line
@@ -139,14 +139,14 @@ Sensor const* SensorManager::getDefaultSensor(int type) 
    return NULL;

}



sp<SensorEventQueue> SensorManager::createEventQueue()

sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName)

{

    sp<SensorEventQueue> queue;



    Mutex::Autolock _l(mLock);

    while (assertStateLocked() == NO_ERROR) {

        sp<ISensorEventConnection> connection =

                mSensorServer->createSensorEventConnection();

                mSensorServer->createSensorEventConnection(packageName);

        if (connection == NULL) {

            // SensorService just died.

            ALOGE("createEventQueue: connection is NULL. SensorService died.");

services/sensorservice/SensorDevice.cpp

+98 −14
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ void SensorDevice::dump(String8& result) 
    Mutex::Autolock _l(mLock);

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

        const Info& info = mActivationCount.valueFor(list[i].handle);

        if (info.batchParams.isEmpty()) continue;

        result.appendFormat("handle=0x%08x, active-count=%zu, batch_period(ms)={ ", list[i].handle,

                            info.batchParams.size());

        for (size_t j = 0; j < info.batchParams.size(); j++) {
@@ -147,8 +148,12 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled) 
    if (enabled) {

        ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%zd", info.batchParams.indexOfKey(ident));



        if (isClientDisabledLocked(ident)) {

            return INVALID_OPERATION;

        }



        if (info.batchParams.indexOfKey(ident) >= 0) {

          if (info.batchParams.size() == 1) {

          if (info.numActiveClients() == 1) {

              // This is the first connection, we need to activate the underlying h/w sensor.

              actuateHardware = true;

          }
@@ -160,7 +165,7 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled) 
        ALOGD_IF(DEBUG_CONNECTIONS, "disable index=%zd", info.batchParams.indexOfKey(ident));



        if (info.removeBatchParamsForIdent(ident) >= 0) {

            if (info.batchParams.size() == 0) {

            if (info.numActiveClients() == 0) {

                // This is the last connection, we need to de-activate the underlying h/w sensor.

                actuateHardware = true;

            } else {
@@ -181,10 +186,15 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled) 
        } else {

            // sensor wasn't enabled for this ident

        }



        if (isClientDisabledLocked(ident)) {

            return NO_ERROR;

        }

    }



    if (actuateHardware) {

        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle, enabled);

        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,

                 enabled);

        err = mSensorDevice->activate(

                reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice), handle, enabled);

        ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
@@ -197,7 +207,7 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled) 
    }



    // On older devices which do not support batch, call setDelay().

    if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1 && info.batchParams.size() > 0) {

    if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1 && info.numActiveClients() > 0) {

        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w setDelay %d %" PRId64, handle,

                 info.bestBatchParams.batchDelay);

        mSensorDevice->setDelay(
@@ -279,6 +289,7 @@ status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodN 
        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;

    }

    Mutex::Autolock _l(mLock);

    if (isClientDisabledLocked(ident)) return INVALID_OPERATION;

    Info& info( mActivationCount.editValueFor(handle) );

    // If the underlying sensor is NOT in continuous mode, setDelay() should return an error.

    // Calling setDelay() in batch mode is an invalid operation.
@@ -298,7 +309,6 @@ status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodN 


int SensorDevice::getHalDeviceVersion() const {

    if (!mSensorDevice) return -1;



    return mSensorDevice->common.version;

}
@@ -306,12 +316,89 @@ status_t SensorDevice::flush(void* ident, int handle) { 
    if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1) {

        return INVALID_OPERATION;

    }

    if (isClientDisabled(ident)) return INVALID_OPERATION;

    ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);

    return mSensorDevice->flush(mSensorDevice, handle);

}



bool SensorDevice::isClientDisabled(void* ident) {

    Mutex::Autolock _l(mLock);

    return isClientDisabledLocked(ident);

}



bool SensorDevice::isClientDisabledLocked(void* ident) {

    return mDisabledClients.indexOf(ident) >= 0;

}



void SensorDevice::enableAllSensors() {

    Mutex::Autolock _l(mLock);

    mDisabledClients.clear();

    const int halVersion = getHalDeviceVersion();

    for (size_t i = 0; i< mActivationCount.size(); ++i) {

        Info& info = mActivationCount.editValueAt(i);

        if (info.batchParams.isEmpty()) continue;

        info.selectBatchParams();

        const int sensor_handle = mActivationCount.keyAt(i);

        ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",

                   sensor_handle);

        status_t err(NO_ERROR);

        if (halVersion > SENSORS_DEVICE_API_VERSION_1_0) {

            err = mSensorDevice->batch(mSensorDevice, sensor_handle,

                 info.bestBatchParams.flags, info.bestBatchParams.batchDelay,

                 info.bestBatchParams.batchTimeout);

            ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));

        }



        if (err == NO_ERROR) {

            err = mSensorDevice->activate(

                    reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),

                    sensor_handle, 1);

            ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));

        }



        if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0) {

             err = mSensorDevice->setDelay(

                    reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),

                    sensor_handle, info.bestBatchParams.batchDelay);

             ALOGE_IF(err, "Error calling setDelay sensor %d (%s)", sensor_handle, strerror(-err));

        }

    }

}



void SensorDevice::disableAllSensors() {

    Mutex::Autolock _l(mLock);

    for (size_t i = 0; i< mActivationCount.size(); ++i) {

        const Info& info = mActivationCount.valueAt(i);

        // Check if this sensor has been activated previously and disable it.

        if (info.batchParams.size() > 0) {

           const int sensor_handle = mActivationCount.keyAt(i);

           ALOGD_IF(DEBUG_CONNECTIONS, "\t>> actuating h/w sensor disable handle=%d ",

                   sensor_handle);

           mSensorDevice->activate(

                   reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),

                   sensor_handle, 0);

           // Add all the connections that were registered for this sensor to the disabled

           // clients list.

           for (int j = 0; j < info.batchParams.size(); ++j) {

               mDisabledClients.add(info.batchParams.keyAt(j));

           }

        }

    }

}



// ---------------------------------------------------------------------------



int SensorDevice::Info::numActiveClients() {

    SensorDevice& device(SensorDevice::getInstance());

    int num = 0;

    for (size_t i = 0; i < batchParams.size(); ++i) {

        if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {

            ++num;

        }

    }

    return num;

}



status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,

                                                    int64_t samplingPeriodNs,

                                                    int64_t maxBatchReportLatencyNs) {
@@ -329,19 +416,16 @@ status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags, 
}



void SensorDevice::Info::selectBatchParams() {

    BatchParams bestParams(-1, -1, -1);



    if (batchParams.size() > 0) {

        BatchParams params = batchParams.valueAt(0);

        bestParams = params;

    }

    BatchParams bestParams(0, -1, -1);

    SensorDevice& device(SensorDevice::getInstance());



    for (size_t i = 1; i < batchParams.size(); ++i) {

    for (size_t i = 0; i < batchParams.size(); ++i) {

        if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;

        BatchParams params = batchParams.valueAt(i);

        if (params.batchDelay < bestParams.batchDelay) {

        if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {

            bestParams.batchDelay = params.batchDelay;

        }

        if (params.batchTimeout < bestParams.batchTimeout) {

        if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {

            bestParams.batchTimeout = params.batchTimeout;

        }

    }