Merge "Virtual device sensor support in sensor service." (fc2e21f9) · Commits · e / os / platform_frameworks_native

libs/sensor/ISensorServer.cpp

+32 −0

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

		class BpSensorServer : public BpInterface<ISensorServer>
		@@ -90,6 +91,25 @@ public:
		return v;
		}

		virtual Vector<Sensor> getRuntimeSensorList(const String16& opPackageName, int deviceId)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
		data.writeString16(opPackageName);
		data.writeInt32(deviceId);
		remote()->transact(GET_RUNTIME_SENSOR_LIST, data, &reply);
		Sensor s;
		Vector<Sensor> v;
		uint32_t n = reply.readUint32();
		v.setCapacity(n);
		while (n) {
		n--;
		reply.read(s);
		v.add(s);
		}
		return v;
		}

		virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName,
		int mode, const String16& opPackageName, const String16& attributionTag)
		{
		@@ -194,6 +214,18 @@ status_t BnSensorServer::onTransact(
		}
		return NO_ERROR;
		}
		case GET_RUNTIME_SENSOR_LIST: {
		CHECK_INTERFACE(ISensorServer, data, reply);
		const String16& opPackageName = data.readString16();
		const int deviceId = data.readInt32();
		Vector<Sensor> v(getRuntimeSensorList(opPackageName, deviceId));
		size_t n = v.size();
		reply->writeUint32(static_cast<uint32_t>(n));
		for (size_t i = 0; i < n; i++) {
		reply->write(v[i]);
		}
		return NO_ERROR;
		}
		case CREATE_SENSOR_DIRECT_CONNECTION: {
		CHECK_INTERFACE(ISensorServer, data, reply);
		const String16& opPackageName = data.readString16();

+13 −0

Original line number	Diff line number	Diff line
		@@ -201,6 +201,19 @@ ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) {
		return static_cast<ssize_t>(count);
		}

		ssize_t SensorManager::getRuntimeSensorList(int deviceId, Vector<Sensor>& runtimeSensors) {
		Mutex::Autolock _l(mLock);
		status_t err = assertStateLocked();
		if (err < 0) {
		return static_cast<ssize_t>(err);
		}

		runtimeSensors = mSensorServer->getRuntimeSensorList(mOpPackageName, deviceId);
		size_t count = runtimeSensors.size();

		return static_cast<ssize_t>(count);
		}

		ssize_t SensorManager::getDynamicSensorList(Sensor const* const** list) {
		Mutex::Autolock _l(mLock);
		status_t err = assertStateLocked();

+1 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,7 @@ public:

		virtual Vector<Sensor> getSensorList(const String16& opPackageName) = 0;
		virtual Vector<Sensor> getDynamicSensorList(const String16& opPackageName) = 0;
		virtual Vector<Sensor> getRuntimeSensorList(const String16& opPackageName, int deviceId) = 0;

		virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName,
		int mode, const String16& opPackageName, const String16& attributionTag) = 0;

+1 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,7 @@ public:
		ssize_t getSensorList(Sensor const* const** list);
		ssize_t getDynamicSensorList(Vector<Sensor>& list);
		ssize_t getDynamicSensorList(Sensor const* const** list);
		ssize_t getRuntimeSensorList(int deviceId, Vector<Sensor>& list);
		Sensor const* getDefaultSensor(int type);
		sp<SensorEventQueue> createEventQueue(
		String8 packageName = String8(""), int mode = 0, String16 attributionTag = String16(""));

+36 −0

Original line number	Diff line number	Diff line
		@@ -87,6 +87,42 @@ VirtualSensor::VirtualSensor() :

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

		RuntimeSensor::RuntimeSensor(const sensor_t& sensor, sp<StateChangeCallback> callback)
		: BaseSensor(sensor), mCallback(std::move(callback)) {
		}

		status_t RuntimeSensor::activate(void*, bool enabled) {
		if (enabled != mEnabled) {
		mEnabled = enabled;
		mCallback->onStateChanged(mEnabled, mSamplingPeriodNs, mBatchReportLatencyNs);
		}
		return OK;
		}

		status_t RuntimeSensor::batch(void*, int, int, int64_t samplingPeriodNs,
		int64_t maxBatchReportLatencyNs) {
		if (mSamplingPeriodNs != samplingPeriodNs \|\| mBatchReportLatencyNs != maxBatchReportLatencyNs) {
		mSamplingPeriodNs = samplingPeriodNs;
		mBatchReportLatencyNs = maxBatchReportLatencyNs;
		if (mEnabled) {
		mCallback->onStateChanged(mEnabled, mSamplingPeriodNs, mBatchReportLatencyNs);
		}
		}
		return OK;
		}

		status_t RuntimeSensor::setDelay(void*, int, int64_t ns) {
		if (mSamplingPeriodNs != ns) {
		mSamplingPeriodNs = ns;
		if (mEnabled) {
		mCallback->onStateChanged(mEnabled, mSamplingPeriodNs, mBatchReportLatencyNs);
		}
		}
		return OK;
		}

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

		ProximitySensor::ProximitySensor(const sensor_t& sensor, SensorService& service)
		: HardwareSensor(sensor), mSensorService(service) {
		}