Merge "Set sensor operation parameter implementation" into oc-dev (691d271b) · Commits · e / os / android_frameworks_native-old

libs/sensor/ISensorServer.cpp

+38 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@ enum {
		ENABLE_DATA_INJECTION,
		GET_DYNAMIC_SENSOR_LIST,
		CREATE_SENSOR_DIRECT_CONNECTION,
		SET_OPERATION_PARAMETER,
		};

		class BpSensorServer : public BpInterface<ISensorServer>
		@@ -117,6 +118,23 @@ public:
		remote()->transact(CREATE_SENSOR_DIRECT_CONNECTION, data, &reply);
		return interface_cast<ISensorEventConnection>(reply.readStrongBinder());
		}

		virtual int setOperationParameter(
		int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) {
		Parcel data, reply;
		data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
		data.writeInt32(type);
		data.writeUint32(static_cast<uint32_t>(floats.size()));
		for (auto i : floats) {
		data.writeFloat(i);
		}
		data.writeUint32(static_cast<uint32_t>(ints.size()));
		for (auto i : ints) {
		data.writeInt32(i);
		}
		remote()->transact(SET_OPERATION_PARAMETER, data, &reply);
		return reply.readInt32();
		}
		};

		// Out-of-line virtual method definition to trigger vtable emission in this
		@@ -183,6 +201,26 @@ status_t BnSensorServer::onTransact(
		reply->writeStrongBinder(IInterface::asBinder(ch));
		return NO_ERROR;
		}
		case SET_OPERATION_PARAMETER: {
		CHECK_INTERFACE(ISensorServer, data, reply);
		int32_t type;
		Vector<float> floats;
		Vector<int32_t> ints;

		type = data.readInt32();
		floats.resize(data.readUint32());
		for (auto &i : floats) {
		i = data.readFloat();
		}
		ints.resize(data.readUint32());
		for (auto &i : ints) {
		i = data.readInt32();
		}

		int32_t ret = setOperationParameter(type, floats, ints);
		reply->writeInt32(ret);
		return NO_ERROR;
		}
		}
		return BBinder::onTransact(code, data, reply, flags);
		}

libs/sensor/SensorManager.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -304,5 +304,14 @@ int SensorManager::configureDirectChannel(int channelNativeHandle, int sensorHan
		return ret;
		}

		int SensorManager::setOperationParameter(
		int type, const Vector<float> &floats, const Vector<int32_t> &ints) {
		Mutex::Autolock _l(mLock);
		if (assertStateLocked() != NO_ERROR) {
		return NO_INIT;
		}
		return mSensorServer->setOperationParameter(type, floats, ints);
		}

		// ----------------------------------------------------------------------------
		}; // namespace android

libs/sensor/include/sensor/ISensorServer.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -50,6 +50,9 @@ public:

		virtual sp<ISensorEventConnection> createSensorDirectConnection(const String16& opPackageName,
		uint32_t size, int32_t type, int32_t format, const native_handle_t *resource) = 0;

		virtual int setOperationParameter(
		int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) = 0;
		};

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

libs/sensor/include/sensor/SensorManager.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -64,6 +64,7 @@ public:
		int createDirectChannel(size_t size, int channelType, const native_handle_t *channelData);
		void destroyDirectChannel(int channelNativeHandle);
		int configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel);
		int setOperationParameter(int type, const Vector<float> &floats, const Vector<int32_t> &ints);

		private:
		// DeathRecipient interface

services/sensorservice/SensorService.cpp

+84 −9

Original line number	Diff line number	Diff line
		@@ -13,23 +13,19 @@
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <cutils/properties.h>

		#include <binder/AppOpsManager.h>
		#include <binder/BinderService.h>
		#include <binder/IServiceManager.h>
		#include <binder/PermissionCache.h>

		#include <cutils/ashmem.h>
		#include <sensor/SensorEventQueue.h>

		#include <cutils/properties.h>
		#include <hardware/sensors.h>
		#include <hardware_legacy/power.h>

		#include <openssl/digest.h>
		#include <openssl/hmac.h>
		#include <openssl/rand.h>
		#include <sensor/SensorEventQueue.h>
		#include <utils/SystemClock.h>

		#include "BatteryService.h"
		#include "CorrectedGyroSensor.h"
		@@ -77,7 +73,8 @@ bool SensorService::sHmacGlobalKeyIsValid = false;
		#define SENSOR_SERVICE_SCHED_FIFO_PRIORITY 10

		// Permissions.
		static const String16 sDump("android.permission.DUMP");
		static const String16 sDumpPermission("android.permission.DUMP");
		static const String16 sLocationHardwarePermission("android.permission.LOCATION_HARDWARE");

		SensorService::SensorService()
		: mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
		@@ -319,7 +316,7 @@ SensorService::~SensorService() {

		status_t SensorService::dump(int fd, const Vector<String16>& args) {
		String8 result;
		if (!PermissionCache::checkCallingPermission(sDump)) {
		if (!PermissionCache::checkCallingPermission(sDumpPermission)) {
		result.appendFormat("Permission Denial: can't dump SensorService from pid=%d, uid=%d\n",
		IPCThreadState::self()->getCallingPid(),
		IPCThreadState::self()->getCallingUid());
		@@ -1032,6 +1029,84 @@ sp<ISensorEventConnection> SensorService::createSensorDirectConnection(
		return conn;
		}

		int SensorService::setOperationParameter(
		int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) {
		Mutex::Autolock _l(mLock);

		// check permission
		int32_t uid;
		bool hasPermission = checkCallingPermission(sLocationHardwarePermission, nullptr, &uid);
		if (!hasPermission \|\| (uid != 1000 && uid != 0)) {
		return PERMISSION_DENIED;
		}

		bool isFloat = true;
		size_t expectSize = INT32_MAX;
		switch (type) {
		case AINFO_LOCAL_GEOMAGNETIC_FIELD:
		isFloat = true;
		expectSize = 3;
		break;
		case AINFO_LOCAL_GRAVITY:
		isFloat = true;
		expectSize = 1;
		break;
		case AINFO_DOCK_STATE:
		case AINFO_HIGH_PERFORMANCE_MODE:
		case AINFO_MAGNETIC_FIELD_CALIBRATION:
		isFloat = false;
		expectSize = 1;
		break;
		default:
		return BAD_VALUE;
		}

		// three events: first one is begin tag, last one is end tag, the one in the middle
		// is the payload.
		sensors_event_t event[3];
		int64_t timestamp = elapsedRealtimeNano();
		for (sensors_event_t* i = event; i < event + 3; i++) {
		*i = (sensors_event_t) {
		.version = sizeof(sensors_event_t),
		.sensor = 0,
		.type = SENSOR_TYPE_ADDITIONAL_INFO,
		.timestamp = timestamp++,
		.additional_info = (additional_info_event_t) {
		.serial = 0
		}
		};
		}

		event[0].additional_info.type = AINFO_BEGIN;
		event[1].additional_info.type = type;
		event[2].additional_info.type = AINFO_END;

		if (isFloat) {
		if (floats.size() != expectSize) {
		return BAD_VALUE;
		}
		for (size_t i = 0; i < expectSize; ++i) {
		event[1].additional_info.data_float[i] = floats[i];
		}
		} else {
		if (ints.size() != expectSize) {
		return BAD_VALUE;
		}
		for (size_t i = 0; i < expectSize; ++i) {
		event[1].additional_info.data_int32[i] = ints[i];
		}
		}

		SensorDevice& dev(SensorDevice::getInstance());
		for (sensors_event_t* i = event; i < event + 3; i++) {
		int ret = dev.injectSensorData(i);
		if (ret != NO_ERROR) {
		return ret;
		}
		}
		return NO_ERROR;
		}

		status_t SensorService::resetToNormalMode() {
		Mutex::Autolock _l(mLock);
		return resetToNormalModeLocked();