am cf818ebb: Merge "Add stringType and requiredPermission to sensors,... (ef89f763) · Commits · e / devices / smdk4412 / android_frameworks_native

include/android/sensor.h

+22 −0

Original line number	Original line	Diff line number	Diff line
	@@ -281,6 +281,28 @@ float ASensor_getResolution(ASensor const* sensor);
	*/		*/
	int ASensor_getMinDelay(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		#ifdef __cplusplus
	};		};

include/gui/Sensor.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -69,6 +69,8 @@ public:
	int32_t getVersion() const;		int32_t getVersion() const;
	int32_t getFifoReservedEventCount() const;		int32_t getFifoReservedEventCount() const;
	int32_t getFifoMaxEventCount() const;		int32_t getFifoMaxEventCount() const;
			const String8& getStringType() const;
			const String8& getRequiredPermission() const;

	// LightFlattenable protocol		// LightFlattenable protocol
	inline bool isFixedSize() const { return false; }		inline bool isFixedSize() const { return false; }
	@@ -89,6 +91,10 @@ private:
	int32_t mVersion;		int32_t mVersion;
	int32_t mFifoReservedEventCount;		int32_t mFifoReservedEventCount;
	int32_t mFifoMaxEventCount;		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	Original line	Diff line number	Diff line
	@@ -48,14 +48,90 @@ Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion)
	mResolution = hwSensor->resolution;		mResolution = hwSensor->resolution;
	mPower = hwSensor->power;		mPower = hwSensor->power;
	mMinDelay = hwSensor->minDelay;		mMinDelay = hwSensor->minDelay;

	// Set fifo event count zero for older devices which do not support batching. Fused		// Set fifo event count zero for older devices which do not support batching. Fused
	// sensors also have their fifo counts set to zero.		// sensors also have their fifo counts set to zero.
	if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {		if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
	mFifoReservedEventCount = hwSensor->fifoReservedEventCount;		mFifoReservedEventCount = hwSensor->fifoReservedEventCount;
	mFifoMaxEventCount = hwSensor->fifoMaxEventCount;		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;		return mFifoMaxEventCount;
	}		}

			const String8& Sensor::getStringType() const {
			return mStringType;
			}

			const String8& Sensor::getRequiredPermission() const {
			return mRequiredPermission;
			}

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

	size_t variableSize =		size_t variableSize =
	sizeof(int32_t) + FlattenableUtils::align<4>(mName.length()) +		sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +
	sizeof(int32_t) + FlattenableUtils::align<4>(mVendor.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;		return fixedSize + variableSize;
	}		}
	@@ -134,14 +220,8 @@ status_t Sensor::flatten(void* buffer, size_t size) const {
	return NO_MEMORY;		return NO_MEMORY;
	}		}

	FlattenableUtils::write(buffer, size, mName.length());		flattenString8(buffer, size, mName);
	memcpy(static_cast<char*>(buffer), mName.string(), mName.length());		flattenString8(buffer, size, mVendor);
	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()));

	FlattenableUtils::write(buffer, size, mVersion);		FlattenableUtils::write(buffer, size, mVersion);
	FlattenableUtils::write(buffer, size, mHandle);		FlattenableUtils::write(buffer, size, mHandle);
	FlattenableUtils::write(buffer, size, mType);		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, mMinDelay);
	FlattenableUtils::write(buffer, size, mFifoReservedEventCount);		FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
	FlattenableUtils::write(buffer, size, mFifoMaxEventCount);		FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
			flattenString8(buffer, size, mStringType);
			flattenString8(buffer, size, mRequiredPermission);
	return NO_ERROR;		return NO_ERROR;
	}		}

	status_t Sensor::unflatten(void const* buffer, size_t size) {		status_t Sensor::unflatten(void const* buffer, size_t size) {
	size_t len;		if (!unflattenString8(buffer, size, mName)) {

	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)) {
	return NO_MEMORY;		return NO_MEMORY;
	}		}
	FlattenableUtils::read(buffer, size, len);		if (!unflattenString8(buffer, size, mVendor)) {
	if (size < len) {
	return NO_MEMORY;		return NO_MEMORY;
	}		}
	mVendor.setTo(static_cast<char const*>(buffer), len);
	FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));

	size_t fixedSize =		size_t fixedSize =
	sizeof(int32_t) * 3 +		sizeof(int32_t) * 3 +
	sizeof(float) * 4 +		sizeof(float) * 4 +
	sizeof(int32_t) * 3;		sizeof(int32_t) * 3;

	if (size < fixedSize) {		if (size < fixedSize) {
	return NO_MEMORY;		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, mMinDelay);
	FlattenableUtils::read(buffer, size, mFifoReservedEventCount);		FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
	FlattenableUtils::read(buffer, size, mFifoMaxEventCount);		FlattenableUtils::read(buffer, size, mFifoMaxEventCount);

			if (!unflattenString8(buffer, size, mStringType)) {
			return NO_MEMORY;
			}
			if (!unflattenString8(buffer, size, mRequiredPermission)) {
			return NO_MEMORY;
			}
	return NO_ERROR;		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		}; // namespace android

services/sensorservice/SensorService.cpp

+77 −18

Original line number	Original line	Diff line number	Diff line
	@@ -206,7 +206,7 @@ status_t SensorService::dump(int fd, const Vector<String16>& /args/)
	String8 result;		String8 result;
	if (!PermissionCache::checkCallingPermission(sDump)) {		if (!PermissionCache::checkCallingPermission(sDump)) {
	result.appendFormat("Permission Denial: "		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()->getCallingPid(),
	IPCThreadState::self()->getCallingUid());		IPCThreadState::self()->getCallingUid());
	} else {		} else {
	@@ -216,10 +216,12 @@ status_t SensorService::dump(int fd, const Vector<String16>& /args/)
	const Sensor& s(mSensorList[i]);		const Sensor& s(mSensorList[i]);
	const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle()));		const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle()));
	result.appendFormat(		result.appendFormat(
	"%-48s\| %-32s \| 0x%08x \| ",		"%-48s\| %-32s\| %-48s\| 0x%08x \| \"%s\"\n\t",
	s.getName().string(),		s.getName().string(),
	s.getVendor().string(),		s.getVendor().string(),
	s.getHandle());		s.getStringType().string(),
			s.getHandle(),
			s.getRequiredPermission().string());

	if (s.getMinDelay() > 0) {		if (s.getMinDelay() > 0) {
	result.appendFormat(		result.appendFormat(
	@@ -230,7 +232,8 @@ status_t SensorService::dump(int fd, const Vector<String16>& /args/)
	: "one-shot \| ");		: "one-shot \| ");
	}		}
	if (s.getFifoMaxEventCount() > 0) {		if (s.getFifoMaxEventCount() > 0) {
	result.appendFormat("getFifoMaxEventCount=%d events \| ", s.getFifoMaxEventCount());		result.appendFormat("FifoMax=%d events \| ",
			s.getFifoMaxEventCount());
	} else {		} else {
	result.append("no batching support \| ");		result.append("no batching support \| ");
	}		}
	@@ -491,10 +494,23 @@ Vector<Sensor> SensorService::getSensorList()
	{		{
	char value[PROPERTY_VALUE_MAX];		char value[PROPERTY_VALUE_MAX];
	property_get("debug.sensors", value, "0");		property_get("debug.sensors", value, "0");
	if (atoi(value)) {		const Vector<Sensor>& initialSensorList = (atoi(value)) ?
	return mUserSensorListDebug;		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()		sp<ISensorEventConnection> SensorService::createSensorEventConnection()
	@@ -540,6 +556,10 @@ void SensorService::cleanupConnection(SensorEventConnection* c)
	BatteryService::cleanup(c->getUid());		BatteryService::cleanup(c->getUid());
	}		}

			Sensor SensorService::getSensorFromHandle(int handle) const {
			return mSensorMap.valueFor(handle)->getSensor();
			}

	status_t SensorService::enable(const sp<SensorEventConnection>& connection,		status_t SensorService::enable(const sp<SensorEventConnection>& connection,
	int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags)		int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags)
	{		{
	@@ -550,6 +570,11 @@ status_t SensorService::enable(const sp<SensorEventConnection>& connection,
	if (sensor == NULL) {		if (sensor == NULL) {
	return BAD_VALUE;		return BAD_VALUE;
	}		}

			if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) {
			return BAD_VALUE;
			}

	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	SensorRecord* rec = mActiveSensors.valueFor(handle);		SensorRecord* rec = mActiveSensors.valueFor(handle);
	if (rec == 0) {		if (rec == 0) {
	@@ -671,6 +696,10 @@ status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection
	if (!sensor)		if (!sensor)
	return BAD_VALUE;		return BAD_VALUE;

			if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) {
			return BAD_VALUE;
			}

	if (ns < 0)		if (ns < 0)
	return BAD_VALUE;		return BAD_VALUE;

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

			if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) {
			return BAD_VALUE;
			}

	if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) {		if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) {
	ALOGE("flush called on Significant Motion sensor");		ALOGE("flush called on Significant Motion sensor");
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	return sensor->flush(connection.get(), handle);		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(		SensorService::SensorRecord::SensorRecord(
	@@ -762,6 +818,9 @@ void SensorService::SensorEventConnection::dump(String8& result) {

	bool SensorService::SensorEventConnection::addSensor(int32_t handle) {		bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
	Mutex::Autolock _l(mConnectionLock);		Mutex::Autolock _l(mConnectionLock);
			if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) {
			return false;
			}
	if (mSensorInfo.indexOfKey(handle) < 0) {		if (mSensorInfo.indexOfKey(handle) < 0) {
	mSensorInfo.add(handle, FlushInfo());		mSensorInfo.add(handle, FlushInfo());
	return true;		return true;

services/sensorservice/SensorService.h

+3 −1

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

	String8 getSensorName(int handle) const;		String8 getSensorName(int handle) const;
	bool isVirtualSensor(int handle) const;		bool isVirtualSensor(int handle) const;
			Sensor getSensorFromHandle(int handle) const;
	void recordLastValue(const sensors_event_t* buffer, size_t count);		void recordLastValue(const sensors_event_t* buffer, size_t count);
	static void sortEventBuffer(sensors_event_t* buffer, size_t count);		static void sortEventBuffer(sensors_event_t* buffer, size_t count);
	Sensor registerSensor(SensorInterface* sensor);		Sensor registerSensor(SensorInterface* sensor);
	@@ -141,7 +142,8 @@ class SensorService :
	const sp<SensorEventConnection>& connection, int handle);		const sp<SensorEventConnection>& connection, int handle);
	void cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,		void cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,
	sensors_event_t const* buffer, const int count);		sensors_event_t const* buffer, const int count);
			static bool canAccessSensor(const Sensor& sensor);
			static bool verifyCanAccessSensor(const Sensor& sensor, const char* operation);
	// constants		// constants
	Vector<Sensor> mSensorList;		Vector<Sensor> mSensorList;
	Vector<Sensor> mUserSensorListDebug;		Vector<Sensor> mUserSensorListDebug;