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

Commit 70018048 authored by Aravind Akella's avatar Aravind Akella
Browse files

Add stringType and requiredPermission to sensors, effectively adding... 

Add stringType and requiredPermission to sensors, effectively adding permission checking for sensors

This reverts commit 4369a4eb.

Change-Id: Ifa8619cc6873470a07a987763d818d78d4232610
parent 4369a4eb

include/android/sensor.h

+22 −0
Original line number Diff line number Diff line
@@ -281,6 +281,28 @@ float ASensor_getResolution(ASensor const* sensor); 
 */

int ASensor_getMinDelay(ASensor const* sensor);



/*

 * Returns the maximum size of batches for this sensor. Batches will often be

 * smaller, as the hardware fifo might be used for other sensors.

 */

int ASensor_getFifoMaxEventCount(ASensor const* sensor);



/*

 * Returns the hardware batch fifo size reserved to this sensor.

 */

int ASensor_getFifoReservedEventCount(ASensor const* sensor);



/*

 * Returns this sensor's string type.

 */

const char* ASensor_getStringType(ASensor const* sensor);



/*

 * Returns the permission required to see or access this sensor, or the

 * empty string if none is required.

 */

const char* ASensor_getRequiredPermission(ASensor const* sensor);





#ifdef __cplusplus

};

include/gui/Sensor.h

+6 −0
Original line number Diff line number Diff line
@@ -69,6 +69,8 @@ public: 
    int32_t getVersion() const;

    int32_t getFifoReservedEventCount() const;

    int32_t getFifoMaxEventCount() const;

    const String8& getStringType() const;

    const String8& getRequiredPermission() const;



    // LightFlattenable protocol

    inline bool isFixedSize() const { return false; }
@@ -89,6 +91,10 @@ private: 
    int32_t mVersion;

    int32_t mFifoReservedEventCount;

    int32_t mFifoMaxEventCount;

    String8 mStringType;

    String8 mRequiredPermission;

    static void flattenString8(void*& buffer, size_t& size, const String8& string8);

    static bool unflattenString8(void const*& buffer, size_t& size, String8& outputString8);

};



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

libs/gui/Sensor.cpp

+126 −32
Original line number Diff line number Diff line
@@ -48,14 +48,90 @@ Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) 
    mResolution = hwSensor->resolution;

    mPower = hwSensor->power;

    mMinDelay = hwSensor->minDelay;



    // Set fifo event count zero for older devices which do not support batching. Fused

    // sensors also have their fifo counts set to zero.

    if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {

        mFifoReservedEventCount = hwSensor->fifoReservedEventCount;

        mFifoMaxEventCount = hwSensor->fifoMaxEventCount;

    } else {

        mFifoReservedEventCount = 0;

        mFifoMaxEventCount = 0;

    }



    // Ensure existing sensors have correct string type and required

    // permissions.

    switch (mType) {

    case SENSOR_TYPE_ACCELEROMETER:

        mStringType = SENSOR_STRING_TYPE_ACCELEROMETER;

        break;

    case SENSOR_TYPE_AMBIENT_TEMPERATURE:

        mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;

        break;

    case SENSOR_TYPE_GAME_ROTATION_VECTOR:

        mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR;

        break;

    case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:

        mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR;

        break;

    case SENSOR_TYPE_GRAVITY:

        mStringType = SENSOR_STRING_TYPE_GRAVITY;

        break;

    case SENSOR_TYPE_GYROSCOPE:

        mStringType = SENSOR_STRING_TYPE_GYROSCOPE;

        break;

    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:

        mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;

        break;

    case SENSOR_TYPE_HEART_RATE:

        mStringType = SENSOR_STRING_TYPE_HEART_RATE;

        mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;

        break;

    case SENSOR_TYPE_LIGHT:

        mStringType = SENSOR_STRING_TYPE_LIGHT;

        break;

    case SENSOR_TYPE_LINEAR_ACCELERATION:

        mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION;

        break;

    case SENSOR_TYPE_MAGNETIC_FIELD:

        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD;

        break;

    case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:

        mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;

        break;

    case SENSOR_TYPE_ORIENTATION:

        mStringType = SENSOR_STRING_TYPE_ORIENTATION;

        break;

    case SENSOR_TYPE_PRESSURE:

        mStringType = SENSOR_STRING_TYPE_PRESSURE;

        break;

    case SENSOR_TYPE_PROXIMITY:

        mStringType = SENSOR_STRING_TYPE_PROXIMITY;

        break;

    case SENSOR_TYPE_RELATIVE_HUMIDITY:

        mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;

        break;

    case SENSOR_TYPE_ROTATION_VECTOR:

        mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR;

        break;

    case SENSOR_TYPE_SIGNIFICANT_MOTION:

        mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION;

        break;

    case SENSOR_TYPE_STEP_COUNTER:

        mStringType = SENSOR_STRING_TYPE_STEP_COUNTER;

        break;

    case SENSOR_TYPE_STEP_DETECTOR:

        mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR;

        break;

    case SENSOR_TYPE_TEMPERATURE:

        mStringType = SENSOR_STRING_TYPE_TEMPERATURE;

        break;

    default:

        // Only pipe the stringType and requiredPermission for custom sensors.

        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->stringType) {

            mStringType = hwSensor->stringType;

        }

        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_2 && hwSensor->requiredPermission) {

            mRequiredPermission = hwSensor->requiredPermission;

        }

        break;

    }

}
@@ -115,6 +191,14 @@ int32_t Sensor::getFifoMaxEventCount() const { 
    return mFifoMaxEventCount;

}



const String8& Sensor::getStringType() const {

    return mStringType;

}



const String8& Sensor::getRequiredPermission() const {

    return mRequiredPermission;

}



size_t Sensor::getFlattenedSize() const

{

    size_t fixedSize =
@@ -123,8 +207,10 @@ size_t Sensor::getFlattenedSize() const 
            sizeof(int32_t) * 3;



    size_t variableSize =

            sizeof(int32_t) + FlattenableUtils::align<4>(mName.length()) +

            sizeof(int32_t) + FlattenableUtils::align<4>(mVendor.length());

            sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +

            sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) +

            sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) +

            sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length());



    return fixedSize + variableSize;

}
@@ -134,14 +220,8 @@ status_t Sensor::flatten(void* buffer, size_t size) const { 
        return NO_MEMORY;

    }



    FlattenableUtils::write(buffer, size, mName.length());

    memcpy(static_cast<char*>(buffer), mName.string(), mName.length());

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(mName.length()));



    FlattenableUtils::write(buffer, size, mVendor.length());

    memcpy(static_cast<char*>(buffer), mVendor.string(), mVendor.length());

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(mVendor.length()));



    flattenString8(buffer, size, mName);

    flattenString8(buffer, size, mVendor);

    FlattenableUtils::write(buffer, size, mVersion);

    FlattenableUtils::write(buffer, size, mHandle);

    FlattenableUtils::write(buffer, size, mType);
@@ -152,38 +232,23 @@ status_t Sensor::flatten(void* buffer, size_t size) const { 
    FlattenableUtils::write(buffer, size, mMinDelay);

    FlattenableUtils::write(buffer, size, mFifoReservedEventCount);

    FlattenableUtils::write(buffer, size, mFifoMaxEventCount);

    flattenString8(buffer, size, mStringType);

    flattenString8(buffer, size, mRequiredPermission);

    return NO_ERROR;

}



status_t Sensor::unflatten(void const* buffer, size_t size) {

    size_t len;



    if (size < sizeof(size_t)) {

        return NO_MEMORY;

    }

    FlattenableUtils::read(buffer, size, len);

    if (size < len) {

        return NO_MEMORY;

    }

    mName.setTo(static_cast<char const*>(buffer), len);

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));





    if (size < sizeof(size_t)) {

    if (!unflattenString8(buffer, size, mName)) {

        return NO_MEMORY;

    }

    FlattenableUtils::read(buffer, size, len);

    if (size < len) {

    if (!unflattenString8(buffer, size, mVendor)) {

        return NO_MEMORY;

    }

    mVendor.setTo(static_cast<char const*>(buffer), len);

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));



    size_t fixedSize =

            sizeof(int32_t) * 3 +

            sizeof(float) * 4 +

            sizeof(int32_t) * 3;



    if (size < fixedSize) {

        return NO_MEMORY;

    }
@@ -198,8 +263,37 @@ status_t Sensor::unflatten(void const* buffer, size_t size) { 
    FlattenableUtils::read(buffer, size, mMinDelay);

    FlattenableUtils::read(buffer, size, mFifoReservedEventCount);

    FlattenableUtils::read(buffer, size, mFifoMaxEventCount);



    if (!unflattenString8(buffer, size, mStringType)) {

        return NO_MEMORY;

    }

    if (!unflattenString8(buffer, size, mRequiredPermission)) {

        return NO_MEMORY;

    }

    return NO_ERROR;

}



void Sensor::flattenString8(void*& buffer, size_t& size,

        const String8& string8) {

    uint32_t len = string8.length();

    FlattenableUtils::write(buffer, size, len);

    memcpy(static_cast<char*>(buffer), string8.string(), len);

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));

}



bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {

    uint32_t len;

    if (size < sizeof(len)) {

        return false;

    }

    FlattenableUtils::read(buffer, size, len);

    if (size < len) {

        return false;

    }

    outputString8.setTo(static_cast<char const*>(buffer), len);

    FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));

    return true;

}



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

}; // namespace android

services/sensorservice/SensorService.cpp

+77 −18
Original line number Diff line number Diff line
@@ -205,7 +205,7 @@ status_t SensorService::dump(int fd, const Vector<String16>& args) 
    String8 result;

    if (!PermissionCache::checkCallingPermission(sDump)) {

        result.appendFormat("Permission Denial: "

                "can't dump SurfaceFlinger from pid=%d, uid=%d\n",

                "can't dump SensorService from pid=%d, uid=%d\n",

                IPCThreadState::self()->getCallingPid(),

                IPCThreadState::self()->getCallingUid());

    } else {
@@ -215,10 +215,12 @@ status_t SensorService::dump(int fd, const Vector<String16>& args) 
            const Sensor& s(mSensorList[i]);

            const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle()));

            result.appendFormat(

                    "%-48s| %-32s | 0x%08x | ",

                    "%-48s| %-32s| %-48s| 0x%08x | \"%s\"\n\t",

                    s.getName().string(),

                    s.getVendor().string(),

                    s.getHandle());

                    s.getStringType().string(),

                    s.getHandle(),

                    s.getRequiredPermission().string());



            if (s.getMinDelay() > 0) {

                result.appendFormat(
@@ -229,7 +231,8 @@ status_t SensorService::dump(int fd, const Vector<String16>& args) 
                        : "one-shot          | ");

            }

            if (s.getFifoMaxEventCount() > 0) {

                result.appendFormat("getFifoMaxEventCount=%d events | ", s.getFifoMaxEventCount());

                result.appendFormat("FifoMax=%d events | ",

                        s.getFifoMaxEventCount());

            } else {

                result.append("no batching support | ");

            }
@@ -490,10 +493,23 @@ Vector<Sensor> SensorService::getSensorList() 
{

    char value[PROPERTY_VALUE_MAX];

    property_get("debug.sensors", value, "0");

    if (atoi(value)) {

        return mUserSensorListDebug;

    const Vector<Sensor>& initialSensorList = (atoi(value)) ?

            mUserSensorListDebug : mUserSensorList;

    Vector<Sensor> accessibleSensorList;

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

        Sensor sensor = initialSensorList[i];

        if (canAccessSensor(sensor)) {

            accessibleSensorList.add(sensor);

        } else {

            String8 infoMessage;

            infoMessage.appendFormat(

                    "Skipped sensor %s because it requires permission %s",

                    sensor.getName().string(),

                    sensor.getRequiredPermission().string());

            ALOGI(infoMessage.string());

        }

    }

    return mUserSensorList;

    return accessibleSensorList;

}



sp<ISensorEventConnection> SensorService::createSensorEventConnection()
@@ -539,6 +555,10 @@ void SensorService::cleanupConnection(SensorEventConnection* c) 
    BatteryService::cleanup(c->getUid());

}



Sensor SensorService::getSensorFromHandle(int handle) const {

    return mSensorMap.valueFor(handle)->getSensor();

}



status_t SensorService::enable(const sp<SensorEventConnection>& connection,

        int handle, nsecs_t samplingPeriodNs,  nsecs_t maxBatchReportLatencyNs, int reservedFlags)

{
@@ -549,6 +569,11 @@ status_t SensorService::enable(const sp<SensorEventConnection>& connection, 
    if (sensor == NULL) {

        return BAD_VALUE;

    }



    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) {

        return BAD_VALUE;

    }



    Mutex::Autolock _l(mLock);

    SensorRecord* rec = mActiveSensors.valueFor(handle);

    if (rec == 0) {
@@ -670,6 +695,10 @@ status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection 
    if (!sensor)

        return BAD_VALUE;



    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) {

        return BAD_VALUE;

    }



    if (ns < 0)

        return BAD_VALUE;
@@ -688,12 +717,39 @@ status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection, 
    if (sensor == NULL) {

        return BAD_VALUE;

    }



    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) {

        return BAD_VALUE;

    }



    if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) {

        ALOGE("flush called on Significant Motion sensor");

        return INVALID_OPERATION;

    }

    return sensor->flush(connection.get(), handle);

}





bool SensorService::canAccessSensor(const Sensor& sensor) {

    String16 permissionString(sensor.getRequiredPermission());

    return permissionString.size() == 0 ||

            PermissionCache::checkCallingPermission(permissionString);

}



bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) {

    if (canAccessSensor(sensor)) {

        return true;

    } else {

        String8 errorMessage;

        errorMessage.appendFormat(

                "%s a sensor (%s) without holding its required permission: %s",

                operation,

                sensor.getName().string(),

                sensor.getRequiredPermission().string());

        return false;

    }

}



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



SensorService::SensorRecord::SensorRecord(
@@ -761,6 +817,9 @@ void SensorService::SensorEventConnection::dump(String8& result) { 


bool SensorService::SensorEventConnection::addSensor(int32_t handle) {

    Mutex::Autolock _l(mConnectionLock);

    if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) {

        return false;

    }

    if (mSensorInfo.indexOfKey(handle) < 0) {

        mSensorInfo.add(handle, FlushInfo());

        return true;

services/sensorservice/SensorService.h

+3 −1
Original line number Diff line number Diff line
@@ -131,6 +131,7 @@ class SensorService : 


    String8 getSensorName(int handle) const;

    bool isVirtualSensor(int handle) const;

    Sensor getSensorFromHandle(int handle) const;

    void recordLastValue(const sensors_event_t* buffer, size_t count);

    static void sortEventBuffer(sensors_event_t* buffer, size_t count);

    Sensor registerSensor(SensorInterface* sensor);
@@ -141,7 +142,8 @@ class SensorService : 
            const sp<SensorEventConnection>& connection, int handle);

    void cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,

            sensors_event_t const* buffer, const int count);



    static bool canAccessSensor(const Sensor& sensor);

    static bool verifyCanAccessSensor(const Sensor& sensor, const char* operation);

    // constants

    Vector<Sensor> mSensorList;

    Vector<Sensor> mUserSensorListDebug;