Checks hidl service and remove hidl call at dump (a8fad9bd) · Commits · e / os / android_frameworks_native-old

services/sensorservice/SensorDevice.cpp

+129 −141

Original line number	Original line	Diff line number	Diff line
	@@ -52,6 +52,31 @@ static status_t StatusFromResult(Result result) {
	}		}

	SensorDevice::SensorDevice() : mHidlTransportErrors(20) {		SensorDevice::SensorDevice() : mHidlTransportErrors(20) {
			if (!connectHidlService()) {
			return;
			}
			checkReturn(mSensors->getSensorsList(
			[&](const auto &list) {
			const size_t count = list.size();

			mActivationCount.setCapacity(count);
			Info model;
			for (size_t i=0 ; i < count; i++) {
			sensor_t sensor;
			convertToSensor(list[i], &sensor);
			mSensorList.push_back(sensor);

			mActivationCount.add(list[i].sensorHandle, model);

			checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
			}
			}));

			mIsDirectReportSupported =
			(checkReturn(mSensors->unregisterDirectChannel(-1)) != Result::INVALID_OPERATION);
			}

			bool SensorDevice::connectHidlService() {
	// SensorDevice may wait upto 100ms * 10 = 1s for hidl service.		// SensorDevice may wait upto 100ms * 10 = 1s for hidl service.
	constexpr auto RETRY_DELAY = std::chrono::milliseconds(100);		constexpr auto RETRY_DELAY = std::chrono::milliseconds(100);
	size_t retry = 10;		size_t retry = 10;
	@@ -74,7 +99,7 @@ SensorDevice::SensorDevice() : mHidlTransportErrors(20) {

	if (--retry <= 0) {		if (--retry <= 0) {
	ALOGE("Cannot connect to ISensors hidl service!");		ALOGE("Cannot connect to ISensors hidl service!");
	return;		break;
	}		}
	// Delay 100ms before retry, hidl service is expected to come up in short time after		// Delay 100ms before retry, hidl service is expected to come up in short time after
	// crash.		// crash.
	@@ -82,29 +107,11 @@ SensorDevice::SensorDevice() : mHidlTransportErrors(20) {
	(initStep == 0) ? "getService()" : "poll() check", retry);		(initStep == 0) ? "getService()" : "poll() check", retry);
	std::this_thread::sleep_for(RETRY_DELAY);		std::this_thread::sleep_for(RETRY_DELAY);
	}		}
			return (mSensors != nullptr);
	checkReturn(mSensors->getSensorsList(
	[&](const auto &list) {
	const size_t count = list.size();

	mActivationCount.setCapacity(count);
	Info model;
	for (size_t i=0 ; i < count; i++) {
	sensor_t sensor;
	convertToSensor(list[i], &sensor);
	mSensorList.push_back(sensor);

	mActivationCount.add(list[i].sensorHandle, model);

	checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
	}
	}));

	mIsDirectReportSupported =
	(checkReturn(mSensors->unregisterDirectChannel(-1)) != Result::INVALID_OPERATION);
	}		}

	void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {		void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
			// not need to check mSensors because this is is only called after successful poll()
	if (connected) {		if (connected) {
	Info model;		Info model;
	mActivationCount.add(handle, model);		mActivationCount.add(handle, model);
	@@ -115,63 +122,37 @@ void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
	}		}

	std::string SensorDevice::dump() const {		std::string SensorDevice::dump() const {
	if (mSensors == NULL) return "HAL not initialized\n";		if (mSensors == nullptr) return "HAL not initialized\n";

	String8 result;		String8 result;
			result.appendFormat("Total %zu h/w sensors, %zu running:\n",
	result.appendFormat("Saw %d hidlTransport Errors\n", mTotalHidlTransportErrors);		mSensorList.size(), mActivationCount.size());
	for (auto it = mHidlTransportErrors.begin() ; it != mHidlTransportErrors.end(); it++ ) {
	result += "\t";
	result += it->toString();
	result += "\n";
	}

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

	result.appendFormat(
	"Total %zu h/w sensors, %zu running:\n",
	count,
	mActivationCount.size());

	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	for (size_t i = 0 ; i < count ; i++) {		for (const auto & s : mSensorList) {
	const Info& info = mActivationCount.valueFor(		int32_t handle = s.handle;
	list[i].sensorHandle);		const Info& info = mActivationCount.valueFor(handle);

	if (info.batchParams.isEmpty()) continue;		if (info.batchParams.isEmpty()) continue;
	result.appendFormat(
	"0x%08x) active-count = %zu; ",		result.appendFormat("0x%08x) active-count = %zu; ", handle, info.batchParams.size());
	list[i].sensorHandle,
	info.batchParams.size());

	result.append("sampling_period(ms) = {");		result.append("sampling_period(ms) = {");
	for (size_t j = 0; j < info.batchParams.size(); j++) {		for (size_t j = 0; j < info.batchParams.size(); j++) {
	const BatchParams& params = info.batchParams.valueAt(j);		const BatchParams& params = info.batchParams.valueAt(j);
	result.appendFormat(		result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
	"%.1f%s",
	params.batchDelay / 1e6f,
	j < info.batchParams.size() - 1 ? ", " : "");		j < info.batchParams.size() - 1 ? ", " : "");
	}		}
	result.appendFormat(		result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
	"}, selected = %.1f ms; ",
	info.bestBatchParams.batchDelay / 1e6f);

	result.append("batching_period(ms) = {");		result.append("batching_period(ms) = {");
	for (size_t j = 0; j < info.batchParams.size(); j++) {		for (size_t j = 0; j < info.batchParams.size(); j++) {
	BatchParams params = info.batchParams.valueAt(j);		BatchParams params = info.batchParams.valueAt(j);

	result.appendFormat(		result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
	"%.1f%s",
	params.batchTimeout / 1e6f,
	j < info.batchParams.size() - 1 ? ", " : "");		j < info.batchParams.size() - 1 ? ", " : "");
	}		}
			result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
	result.appendFormat(
	"}, selected = %.1f ms\n",
	info.bestBatchParams.batchTimeout / 1e6f);
	}		}
	}));

	return result.string();		return result.string();
	}		}
	@@ -187,7 +168,7 @@ status_t SensorDevice::initCheck() const {
	}		}

	ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {		ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
	if (mSensors == NULL) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;

	ssize_t err;		ssize_t err;
	int numHidlTransportErrors = 0;		int numHidlTransportErrors = 0;
	@@ -239,7 +220,7 @@ void SensorDevice::autoDisable(void *ident, int handle) {
	}		}

	status_t SensorDevice::activate(void* ident, int handle, int enabled) {		status_t SensorDevice::activate(void* ident, int handle, int enabled) {
	if (mSensors == NULL) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;

	status_t err(NO_ERROR);		status_t err(NO_ERROR);
	bool actuateHardware = false;		bool actuateHardware = false;
	@@ -328,7 +309,7 @@ status_t SensorDevice::batch(
	int flags,		int flags,
	int64_t samplingPeriodNs,		int64_t samplingPeriodNs,
	int64_t maxBatchReportLatencyNs) {		int64_t maxBatchReportLatencyNs) {
	if (mSensors == NULL) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;

	if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {		if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
	samplingPeriodNs = MINIMUM_EVENTS_PERIOD;		samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
	@@ -382,7 +363,7 @@ status_t SensorDevice::batch(
	}		}

	status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {		status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
	if (mSensors == NULL) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;
	if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {		if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
	samplingPeriodNs = MINIMUM_EVENTS_PERIOD;		samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
	}		}
	@@ -407,11 +388,12 @@ status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodN
	}		}

	int SensorDevice::getHalDeviceVersion() const {		int SensorDevice::getHalDeviceVersion() const {
	if (mSensors == NULL) return -1;		if (mSensors == nullptr) return -1;
	return SENSORS_DEVICE_API_VERSION_1_4;		return SENSORS_DEVICE_API_VERSION_1_4;
	}		}

	status_t SensorDevice::flush(void* ident, int handle) {		status_t SensorDevice::flush(void* ident, int handle) {
			if (mSensors == nullptr) return NO_INIT;
	if (isClientDisabled(ident)) return INVALID_OPERATION;		if (isClientDisabled(ident)) return INVALID_OPERATION;
	ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
	return StatusFromResult(checkReturn(mSensors->flush(handle)));		return StatusFromResult(checkReturn(mSensors->flush(handle)));
	@@ -427,6 +409,7 @@ bool SensorDevice::isClientDisabledLocked(void* ident) {
	}		}

	void SensorDevice::enableAllSensors() {		void SensorDevice::enableAllSensors() {
			if (mSensors == nullptr) return;
	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	mDisabledClients.clear();		mDisabledClients.clear();
	ALOGI("cleared mDisabledClients");		ALOGI("cleared mDisabledClients");
	@@ -453,6 +436,7 @@ void SensorDevice::enableAllSensors() {
	}		}

	void SensorDevice::disableAllSensors() {		void SensorDevice::disableAllSensors() {
			if (mSensors == nullptr) return;
	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	for (size_t i = 0; i< mActivationCount.size(); ++i) {		for (size_t i = 0; i< mActivationCount.size(); ++i) {
	const Info& info = mActivationCount.valueAt(i);		const Info& info = mActivationCount.valueAt(i);
	@@ -475,6 +459,7 @@ void SensorDevice::disableAllSensors() {

	status_t SensorDevice::injectSensorData(		status_t SensorDevice::injectSensorData(
	const sensors_event_t *injected_sensor_event) {		const sensors_event_t *injected_sensor_event) {
			if (mSensors == nullptr) return NO_INIT;
	ALOGD_IF(DEBUG_CONNECTIONS,		ALOGD_IF(DEBUG_CONNECTIONS,
	"sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",		"sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
	injected_sensor_event->sensor,		injected_sensor_event->sensor,
	@@ -490,72 +475,14 @@ status_t SensorDevice::injectSensorData(
	}		}

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

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

	int SensorDevice::Info::numActiveClients() {
	SensorDevice& device(SensorDevice::getInstance());
	int num = 0;
	for (size_t i = 0; i < batchParams.size(); ++i) {
	if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
	++num;
	}
	}
	return num;
	}

	status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
	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)",
	ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
	return BAD_INDEX;
	}
	BatchParams& params = batchParams.editValueAt(index);
	params.flags = flags;
	params.batchDelay = samplingPeriodNs;
	params.batchTimeout = maxBatchReportLatencyNs;
	return NO_ERROR;
	}

	void SensorDevice::Info::selectBatchParams() {
	BatchParams bestParams(0, -1, -1);
	SensorDevice& device(SensorDevice::getInstance());

	for (size_t i = 0; i < batchParams.size(); ++i) {
	if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
	BatchParams params = batchParams.valueAt(i);
	if (bestParams.batchDelay == -1 \|\| params.batchDelay < bestParams.batchDelay) {
	bestParams.batchDelay = params.batchDelay;
	}
	if (bestParams.batchTimeout == -1 \|\| params.batchTimeout < bestParams.batchTimeout) {
	bestParams.batchTimeout = params.batchTimeout;
	}
	}
	bestBatchParams = bestParams;
	}

	ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
	ssize_t idx = batchParams.removeItem(ident);
	if (idx >= 0) {
	selectBatchParams();
	}
	return idx;
	}

	void SensorDevice::notifyConnectionDestroyed(void* ident) {
	Mutex::Autolock _l(mLock);
	mDisabledClients.remove(ident);
	}

	int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {		int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
			if (mSensors == nullptr) return NO_INIT;
	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);

	SharedMemType type;		SharedMemType type;
	@@ -596,12 +523,14 @@ int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory)
	}		}

	void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {		void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
			if (mSensors == nullptr) return;
	Mutex::Autolock _l(mLock);		Mutex::Autolock _l(mLock);
	checkReturn(mSensors->unregisterDirectChannel(channelHandle));		checkReturn(mSensors->unregisterDirectChannel(channelHandle));
	}		}

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

	RateLevel rate;		RateLevel rate;
	@@ -639,6 +568,65 @@ int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
	return ret;		return ret;
	}		}

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

			int SensorDevice::Info::numActiveClients() {
			SensorDevice& device(SensorDevice::getInstance());
			int num = 0;
			for (size_t i = 0; i < batchParams.size(); ++i) {
			if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
			++num;
			}
			}
			return num;
			}

			status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
			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)",
			ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
			return BAD_INDEX;
			}
			BatchParams& params = batchParams.editValueAt(index);
			params.flags = flags;
			params.batchDelay = samplingPeriodNs;
			params.batchTimeout = maxBatchReportLatencyNs;
			return NO_ERROR;
			}

			void SensorDevice::Info::selectBatchParams() {
			BatchParams bestParams(0, -1, -1);
			SensorDevice& device(SensorDevice::getInstance());

			for (size_t i = 0; i < batchParams.size(); ++i) {
			if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
			BatchParams params = batchParams.valueAt(i);
			if (bestParams.batchDelay == -1 \|\| params.batchDelay < bestParams.batchDelay) {
			bestParams.batchDelay = params.batchDelay;
			}
			if (bestParams.batchTimeout == -1 \|\| params.batchTimeout < bestParams.batchTimeout) {
			bestParams.batchTimeout = params.batchTimeout;
			}
			}
			bestBatchParams = bestParams;
			}

			ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
			ssize_t idx = batchParams.removeItem(ident);
			if (idx >= 0) {
			selectBatchParams();
			}
			return idx;
			}

			void SensorDevice::notifyConnectionDestroyed(void* ident) {
			Mutex::Autolock _l(mLock);
			mDisabledClients.remove(ident);
			}

	bool SensorDevice::isDirectReportSupported() const {		bool SensorDevice::isDirectReportSupported() const {
	return mIsDirectReportSupported;		return mIsDirectReportSupported;
	}		}

services/sensorservice/SensorDevice.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -161,6 +161,7 @@ private:
	// Use this vector to determine which client is activated or deactivated.		// Use this vector to determine which client is activated or deactivated.
	SortedVector<void *> mDisabledClients;		SortedVector<void *> mDisabledClients;
	SensorDevice();		SensorDevice();
			bool connectHidlService();

	static void handleHidlDeath(const std::string &detail);		static void handleHidlDeath(const std::string &detail);
	template<typename T>		template<typename T>