Add stringType and requiredPermission to sensors, effectively adding... (c57a019e) · Commits · e / os / android_frameworks_native-old

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;