Run clang-format on SensorDevice code (d6b9e21e) · Commits · e / os / android_frameworks_native

services/sensorservice/SensorDevice.cpp

+226 −245

Original line number	Diff line number	Diff line
		@@ -23,31 +23,31 @@

		#include <android-base/logging.h>
		#include <android/util/ProtoOutputStream.h>
		#include <cutils/atomic.h>
		#include <frameworks/base/core/proto/android/service/sensor_service.proto.h>
		#include <sensors/convert.h>
		#include <cutils/atomic.h>
		#include <utils/Errors.h>
		#include <utils/Singleton.h>

		#include <cstddef>
		#include <chrono>
		#include <cinttypes>
		#include <cstddef>
		#include <thread>

		using namespace android::hardware::sensors;
		using namespace android::hardware::sensors::V1_0;
		using namespace android::hardware::sensors::V1_0::implementation;
		using android::hardware::hidl_vec;
		using android::hardware::Return;
		using android::hardware::sensors::V2_0::EventQueueFlagBits;
		using android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
		using android::hardware::sensors::V2_1::ISensorsCallback;
		using android::hardware::sensors::V2_1::implementation::convertToOldSensorInfo;
		using android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos;
		using android::hardware::sensors::V2_1::implementation::convertToNewEvents;
		using android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos;
		using android::hardware::sensors::V2_1::implementation::convertToOldSensorInfo;
		using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV1_0;
		using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_0;
		using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_1;
		using android::hardware::hidl_vec;
		using android::hardware::Return;
		using android::SensorDeviceUtils::HidlServiceRegistrationWaiter;
		using android::util::ProtoOutputStream;

		@@ -87,8 +87,7 @@ enum EventQueueFlagBitsInternal : uint32_t {
		} // anonymous namespace

		void SensorsHalDeathReceivier::serviceDied(
		uint64_t /* cookie */,
		const wp<::android::hidl::base::V1_0::IBase>& /* service */) {
		uint64_t /* cookie /, const wp<::android::hidl::base::V1_0::IBase>& / service */) {
		ALOGW("Sensors HAL died, attempting to reconnect.");
		SensorDevice::getInstance().prepareForReconnect();
		}
		@@ -132,8 +131,7 @@ SensorDevice::SensorDevice()
		}

		void SensorDevice::initializeSensorList() {
		checkReturn(mSensors->getSensorsList(
		[&](const auto &list) {
		checkReturn(mSensors->getSensorsList([&](const auto& list) {
		const size_t count = list.size();

		mActivationCount.setCapacity(count);
		@@ -150,16 +148,16 @@ void SensorDevice::initializeSensorList() {
		// production with a resolution of 0.
		if (sensor.resolution != 0) {
		float quantizedRange = sensor.maxRange;
		SensorDeviceUtils::quantizeValue(
		&quantizedRange, sensor.resolution, /factor=/ 1);
		SensorDeviceUtils::quantizeValue(&quantizedRange, sensor.resolution,
		/factor=/1);
		// Only rewrite maxRange if the requantization produced a "significant"
		// change, which is fairly arbitrarily defined as resolution / 8.
		// Smaller deltas are permitted, as they may simply be due to floating
		// point representation error, etc.
		if (fabsf(sensor.maxRange - quantizedRange) > sensor.resolution / 8) {
		ALOGW("%s's max range %.12f is not a multiple of the resolution "
		"%.12f - updated to %.12f", sensor.name, sensor.maxRange,
		sensor.resolution, quantizedRange);
		"%.12f - updated to %.12f",
		sensor.name, sensor.maxRange, sensor.resolution, quantizedRange);
		sensor.maxRange = quantizedRange;
		}
		} else {
		@@ -171,8 +169,8 @@ void SensorDevice::initializeSensorList() {
		// Check and clamp power if it is 0 (or close)
		constexpr float MIN_POWER_MA = 0.001; // 1 microAmp
		if (sensor.power < MIN_POWER_MA) {
		ALOGI("%s's reported power %f invalid, clamped to %f",
		sensor.name, sensor.power, MIN_POWER_MA);
		ALOGI("%s's reported power %f invalid, clamped to %f", sensor.name, sensor.power,
		MIN_POWER_MA);
		sensor.power = MIN_POWER_MA;
		}
		mSensorList.push_back(sensor);
		@@ -182,8 +180,7 @@ void SensorDevice::initializeSensorList() {
		// Only disable all sensors on HAL 1.0 since HAL 2.0
		// handles this in its initialize method
		if (!mSensors->supportsMessageQueues()) {
		checkReturn(mSensors->activate(list[i].sensorHandle,
		0 /* enabled */));
		checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
		}
		}
		}));
		@@ -278,23 +275,22 @@ SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV2_1() {
		SensorDevice::HalConnectionStatus SensorDevice::initializeHidlServiceV2_X() {
		HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;

		mWakeLockQueue = std::make_unique<WakeLockQueue>(
		SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
		mWakeLockQueue =
		std::make_unique<WakeLockQueue>(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
		true /* configureEventFlagWord */);

		hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
		hardware::EventFlag::createEventFlag(mSensors->getEventQueue()->getEventFlagWord(), &mEventQueueFlag);
		hardware::EventFlag::createEventFlag(mSensors->getEventQueue()->getEventFlagWord(),
		&mEventQueueFlag);

		hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
		hardware::EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(),
		&mWakeLockQueueFlag);
		hardware::EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(), &mWakeLockQueueFlag);

		CHECK(mSensors != nullptr && mWakeLockQueue != nullptr &&
		mEventQueueFlag != nullptr && mWakeLockQueueFlag != nullptr);
		CHECK(mSensors != nullptr && mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&
		mWakeLockQueueFlag != nullptr);

		status_t status = checkReturnAndGetStatus(mSensors->initialize(
		*mWakeLockQueue->getDesc(),
		new SensorsCallback()));
		status_t status = checkReturnAndGetStatus(
		mSensors->initialize(*mWakeLockQueue->getDesc(), new SensorsCallback()));

		if (status != NO_ERROR) {
		connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
		@@ -378,16 +374,14 @@ bool SensorDevice::sensorIsEquivalent(const sensor_t& prevSensor, const sensor_t
		(strcmp(prevSensor.vendor, newSensor.vendor) != 0) \|\|
		(strcmp(prevSensor.stringType, newSensor.stringType) != 0) \|\|
		(strcmp(prevSensor.requiredPermission, newSensor.requiredPermission) != 0) \|\|
		(prevSensor.version != newSensor.version) \|\|
		(prevSensor.type != newSensor.type) \|\|
		(prevSensor.version != newSensor.version) \|\| (prevSensor.type != newSensor.type) \|\|
		(std::abs(prevSensor.maxRange - newSensor.maxRange) > 0.001f) \|\|
		(std::abs(prevSensor.resolution - newSensor.resolution) > 0.001f) \|\|
		(std::abs(prevSensor.power - newSensor.power) > 0.001f) \|\|
		(prevSensor.minDelay != newSensor.minDelay) \|\|
		(prevSensor.fifoReservedEventCount != newSensor.fifoReservedEventCount) \|\|
		(prevSensor.fifoMaxEventCount != newSensor.fifoMaxEventCount) \|\|
		(prevSensor.maxDelay != newSensor.maxDelay) \|\|
		(prevSensor.flags != newSensor.flags)) {
		(prevSensor.maxDelay != newSensor.maxDelay) \|\| (prevSensor.flags != newSensor.flags)) {
		equivalent = false;
		}
		return equivalent;
		@@ -444,7 +438,8 @@ std::string SensorDevice::dump() const {
		for (size_t j = 0; j < info.batchParams.size(); j++) {
		const BatchParams& params = info.batchParams[j];
		result.appendFormat("%.1f%s%s", params.mTSample / 1e6f,
		isClientDisabledLocked(info.batchParams.keyAt(j)) ? "(disabled)" : "",
		isClientDisabledLocked(info.batchParams.keyAt(j)) ? "(disabled)"
		: "",
		(j < info.batchParams.size() - 1) ? ", " : "");
		}
		result.appendFormat("}, selected = %.2f ms; ", info.bestBatchParams.mTSample / 1e6f);
		@@ -453,7 +448,8 @@ std::string SensorDevice::dump() const {
		for (size_t j = 0; j < info.batchParams.size(); j++) {
		const BatchParams& params = info.batchParams[j];
		result.appendFormat("%.1f%s%s", params.mTBatch / 1e6f,
		isClientDisabledLocked(info.batchParams.keyAt(j)) ? "(disabled)" : "",
		isClientDisabledLocked(info.batchParams.keyAt(j)) ? "(disabled)"
		: "",
		(j < info.batchParams.size() - 1) ? ", " : "");
		}
		result.appendFormat("}, selected = %.2f ms\n", info.bestBatchParams.mTBatch / 1e6f);
		@@ -531,13 +527,12 @@ ssize_t SensorDevice::pollHal(sensors_event_t* buffer, size_t count) {

		do {
		auto ret = mSensors->poll(
		count,
		[&](auto result,
		const auto &events,
		const auto &dynamicSensorsAdded) {
		count, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) {
		if (result == Result::OK) {
		convertToSensorEventsAndQuantize(convertToNewEvents(events),
		convertToNewSensorInfos(dynamicSensorsAdded), buffer);
		convertToNewSensorInfos(
		dynamicSensorsAdded),
		buffer);
		err = (ssize_t)events.size();
		} else {
		err = statusFromResult(result);
		@@ -581,7 +576,8 @@ ssize_t SensorDevice::pollFmq(sensors_event_t* buffer, size_t maxNumEventsToRead
		// events is not available, then read() would return no events, possibly introducing
		// additional latency in delivering events to applications.
		mEventQueueFlag->wait(asBaseType(EventQueueFlagBits::READ_AND_PROCESS) \|
		asBaseType(INTERNAL_WAKE), &eventFlagState);
		asBaseType(INTERNAL_WAKE),
		&eventFlagState);
		availableEvents = mSensors->getEventQueue()->availableToRead();

		if ((eventFlagState & asBaseType(INTERNAL_WAKE)) && mReconnecting) {
		@@ -600,12 +596,13 @@ ssize_t SensorDevice::pollFmq(sensors_event_t* buffer, size_t maxNumEventsToRead
		for (size_t i = 0; i < eventsToRead; i++) {
		convertToSensorEvent(mEventBuffer[i], &buffer[i]);
		android::SensorDeviceUtils::quantizeSensorEventValues(&buffer[i],
		getResolutionForSensor(buffer[i].sensor));
		getResolutionForSensor(
		buffer[i].sensor));
		}
		eventsRead = eventsToRead;
		} else {
		ALOGW("Failed to read %zu events, currently %zu events available",
		eventsToRead, availableEvents);
		ALOGW("Failed to read %zu events, currently %zu events available", eventsToRead,
		availableEvents);
		}
		}

		@@ -627,8 +624,7 @@ Return<void> SensorDevice::onDynamicSensorsConnected(
		sensor_t* sensor = new sensor_t();
		convertToSensor(convertToOldSensorInfo(info), sensor);

		mConnectedDynamicSensors.insert(
		std::make_pair(sensor->handle, sensor));
		mConnectedDynamicSensors.insert(std::make_pair(sensor->handle, sensor));
		}

		mDynamicSensorsCv.notify_all();
		@@ -687,15 +683,15 @@ status_t SensorDevice::activateLocked(void* ident, int handle, int enabled) {
		Info& info(mActivationCount.editValueAt(activationIndex));

		ALOGD_IF(DEBUG_CONNECTIONS,
		"SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%zu",
		ident, handle, enabled, info.batchParams.size());
		"SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%zu", ident,
		handle, enabled, info.batchParams.size());

		if (enabled) {
		ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%zd", info.batchParams.indexOfKey(ident));

		if (isClientDisabledLocked(ident)) {
		ALOGW("SensorDevice::activate, isClientDisabledLocked(%p):true, handle:%d",
		ident, handle);
		ALOGW("SensorDevice::activate, isClientDisabledLocked(%p):true, handle:%d", ident,
		handle);
		return NO_ERROR;
		}

		@@ -726,11 +722,10 @@ status_t SensorDevice::activateLocked(void* ident, int handle, int enabled) {
		// Call batch for this sensor with the previously calculated best effort
		// batch_rate and timeout. One of the apps has unregistered for sensor
		// events, and the best effort batch parameters might have changed.
		ALOGD_IF(DEBUG_CONNECTIONS,
		"\t>>> actuating h/w batch 0x%08x %" PRId64 " %" PRId64, handle,
		info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
		checkReturn(mSensors->batch(
		handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch));
		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w batch 0x%08x %" PRId64 " %" PRId64,
		handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
		checkReturn(mSensors->batch(handle, info.bestBatchParams.mTSample,
		info.bestBatchParams.mTBatch));
		}
		} else {
		// sensor wasn't enabled for this ident
		@@ -767,11 +762,7 @@ status_t SensorDevice::doActivateHardwareLocked(int handle, bool enabled) {
		return err;
		}

		status_t SensorDevice::batch(
		void* ident,
		int handle,
		int flags,
		int64_t samplingPeriodNs,
		status_t SensorDevice::batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
		int64_t maxBatchReportLatencyNs) {
		if (mSensors == nullptr) return NO_INIT;

		@@ -783,7 +774,8 @@ status_t SensorDevice::batch(
		}

		ALOGD_IF(DEBUG_CONNECTIONS,
		"SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64 " timeout=%" PRId64,
		"SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64
		" timeout=%" PRId64,
		ident, handle, flags, samplingPeriodNs, maxBatchReportLatencyNs);

		Mutex::Autolock _l(mLock);
		@@ -809,9 +801,8 @@ status_t SensorDevice::batchLocked(void* ident, int handle, int flags, int64_t s

		status_t err = updateBatchParamsLocked(handle, info);
		if (err != NO_ERROR) {
		ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s",
		mSensors.get(), handle, info.bestBatchParams.mTSample,
		info.bestBatchParams.mTBatch, strerror(-err));
		ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s", mSensors.get(),
		handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch, strerror(-err));
		info.removeBatchParamsForIdent(ident);
		}

		@@ -824,8 +815,8 @@ status_t SensorDevice::updateBatchParamsLocked(int handle, Info &info) {
		info.selectBatchParams();

		ALOGD_IF(DEBUG_CONNECTIONS,
		"\t>>> curr_period=%" PRId64 " min_period=%" PRId64
		" curr_timeout=%" PRId64 " min_timeout=%" PRId64,
		"\t>>> curr_period=%" PRId64 " min_period=%" PRId64 " curr_timeout=%" PRId64
		" min_timeout=%" PRId64,
		prevBestBatchParams.mTSample, info.bestBatchParams.mTSample,
		prevBestBatchParams.mTBatch, info.bestBatchParams.mTBatch);

		@@ -834,8 +825,8 @@ status_t SensorDevice::updateBatchParamsLocked(int handle, Info &info) {
		if (prevBestBatchParams != info.bestBatchParams && info.numActiveClients() > 0) {
		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH 0x%08x %" PRId64 " %" PRId64, handle,
		info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
		err = checkReturnAndGetStatus(mSensors->batch(
		handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch));
		err = checkReturnAndGetStatus(mSensors->batch(handle, info.bestBatchParams.mTSample,
		info.bestBatchParams.mTBatch));
		}

		return err;
		@@ -905,8 +896,7 @@ void SensorDevice::setUidStateForConnection(void* ident, SensorService::UidState
		bool disable = info.numActiveClients() == 0 && info.isActive;
		bool enable = info.numActiveClients() > 0 && !info.isActive;

		if ((enable \|\| disable) &&
		doActivateHardwareLocked(handle, enable) == NO_ERROR) {
		if ((enable \|\| disable) && doActivateHardwareLocked(handle, enable) == NO_ERROR) {
		info.isActive = enable;
		}
		}
		@@ -942,8 +932,8 @@ void SensorDevice::enableAllSensors() {
		Mutex::Autolock _l(mLock);

		for (void* client : getDisabledClientsLocked()) {
		removeDisabledReasonForIdentLocked(
		client, DisabledReason::DISABLED_REASON_SERVICE_RESTRICTED);
		removeDisabledReasonForIdentLocked(client,
		DisabledReason::DISABLED_REASON_SERVICE_RESTRICTED);
		}

		for (size_t i = 0; i < mActivationCount.size(); ++i) {
		@@ -953,8 +943,7 @@ void SensorDevice::enableAllSensors() {
		const int sensor_handle = mActivationCount.keyAt(i);
		ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
		sensor_handle);
		status_t err = checkReturnAndGetStatus(mSensors->batch(
		sensor_handle,
		status_t err = checkReturnAndGetStatus(mSensors->batch(sensor_handle,
		info.bestBatchParams.mTSample,
		info.bestBatchParams.mTBatch));
		ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
		@@ -985,8 +974,8 @@ void SensorDevice::disableAllSensors() {
		// Add all the connections that were registered for this sensor to the disabled
		// clients list.
		for (size_t j = 0; j < info.batchParams.size(); ++j) {
		addDisabledReasonForIdentLocked(
		info.batchParams.keyAt(j), DisabledReason::DISABLED_REASON_SERVICE_RESTRICTED);
		addDisabledReasonForIdentLocked(info.batchParams.keyAt(j),
		DisabledReason::DISABLED_REASON_SERVICE_RESTRICTED);
		ALOGI("added %p to mDisabledClients", info.batchParams.keyAt(j));
		}

		@@ -995,16 +984,14 @@ void SensorDevice::disableAllSensors() {
		}
		}

		status_t SensorDevice::injectSensorData(
		const sensors_event_t *injected_sensor_event) {
		status_t SensorDevice::injectSensorData(const sensors_event_t* injected_sensor_event) {
		if (mSensors == nullptr) return NO_INIT;
		ALOGD_IF(DEBUG_CONNECTIONS,
		"sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
		injected_sensor_event->sensor,
		injected_sensor_event->timestamp, injected_sensor_event->data[0],
		injected_sensor_event->data[1], injected_sensor_event->data[2],
		injected_sensor_event->data[3], injected_sensor_event->data[4],
		injected_sensor_event->data[5]);
		injected_sensor_event->sensor, injected_sensor_event->timestamp,
		injected_sensor_event->data[0], injected_sensor_event->data[1],
		injected_sensor_event->data[2], injected_sensor_event->data[3],
		injected_sensor_event->data[4], injected_sensor_event->data[5]);

		Event ev;
		V2_1::implementation::convertFromSensorEvent(*injected_sensor_event, &ev);
		@@ -1014,8 +1001,8 @@ status_t SensorDevice::injectSensorData(

		status_t SensorDevice::setMode(uint32_t mode) {
		if (mSensors == nullptr) return NO_INIT;
		return checkReturnAndGetStatus(mSensors->setOperationMode(
		static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
		return checkReturnAndGetStatus(
		mSensors->setOperationMode(static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
		}

		int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
		@@ -1048,8 +1035,7 @@ int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory)
		};

		int32_t ret;
		checkReturn(mSensors->registerDirectChannel(mem,
		[&ret](auto result, auto channelHandle) {
		checkReturn(mSensors->registerDirectChannel(mem, [&ret](auto result, auto channelHandle) {
		if (result == Result::OK) {
		ret = channelHandle;
		} else {
		@@ -1065,8 +1051,8 @@ void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
		checkReturn(mSensors->unregisterDirectChannel(channelHandle));
		}

		int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
		int32_t channelHandle, const struct sensors_direct_cfg_t *config) {
		int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
		const struct sensors_direct_cfg_t* config) {
		if (mSensors == nullptr) return NO_INIT;
		Mutex::Autolock _l(mLock);

		@@ -1118,13 +1104,12 @@ int SensorDevice::Info::numActiveClients() const {
		return num;
		}

		status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int,
		int64_t samplingPeriodNs,
		status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int, int64_t samplingPeriodNs,
		int64_t maxBatchReportLatencyNs) {
		ssize_t index = batchParams.indexOfKey(ident);
		if (index < 0) {
		ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64
		" timeout=%" PRId64 ") failed (%s)",
		ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64
		") failed (%s)",
		ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
		return BAD_INDEX;
		}
		@@ -1168,8 +1153,7 @@ bool SensorDevice::isDirectReportSupported() const {
		return mIsDirectReportSupported;
		}

		void SensorDevice::convertToSensorEvent(
		const Event &src, sensors_event_t *dst) {
		void SensorDevice::convertToSensorEvent(const Event& src, sensors_event_t* dst) {
		V2_1::implementation::convertToSensorEvent(src, dst);

		if (src.sensorType == V2_1::SensorType::DYNAMIC_SENSOR_META) {
		@@ -1184,10 +1168,9 @@ void SensorDevice::convertToSensorEvent(
		// marks it as oneway.
		auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
		if (it == mConnectedDynamicSensors.end()) {
		mDynamicSensorsCv.wait_for(lock, MAX_DYN_SENSOR_WAIT,
		[&, dyn]{
		return mConnectedDynamicSensors.find(dyn.sensorHandle)
		!= mConnectedDynamicSensors.end();
		mDynamicSensorsCv.wait_for(lock, MAX_DYN_SENSOR_WAIT, [&, dyn] {
		return mConnectedDynamicSensors.find(dyn.sensorHandle) !=
		mConnectedDynamicSensors.end();
		});
		it = mConnectedDynamicSensors.find(dyn.sensorHandle);
		CHECK(it != mConnectedDynamicSensors.end());
		@@ -1195,18 +1178,15 @@ void SensorDevice::convertToSensorEvent(

		dst->dynamic_sensor_meta.sensor = it->second;

		memcpy(dst->dynamic_sensor_meta.uuid,
		dyn.uuid.data(),
		memcpy(dst->dynamic_sensor_meta.uuid, dyn.uuid.data(),
		sizeof(dst->dynamic_sensor_meta.uuid));
		}
		}
		}

		void SensorDevice::convertToSensorEventsAndQuantize(
		const hidl_vec<Event> &src,
		void SensorDevice::convertToSensorEventsAndQuantize(const hidl_vec<Event>& src,
		const hidl_vec<SensorInfo>& dynamicSensorsAdded,
		sensors_event_t* dst) {

		if (dynamicSensorsAdded.size() > 0) {
		onDynamicSensorsConnected(dynamicSensorsAdded);
		}
		@@ -1214,7 +1194,8 @@ void SensorDevice::convertToSensorEventsAndQuantize(
		for (size_t i = 0; i < src.size(); ++i) {
		V2_1::implementation::convertToSensorEvent(src[i], &dst[i]);
		android::SensorDeviceUtils::quantizeSensorEventValues(&dst[i],
		getResolutionForSensor(dst[i].sensor));
		getResolutionForSensor(
		dst[i].sensor));
		}
		}

services/sensorservice/SensorDevice.h

+43 −47

File changed.

Preview size limit exceeded, changes collapsed.