Snap for 5778854 from 8813be6341051258bfb4c49642dc3300796b0e6c to qt-c2f2-release (2a96ed7f) · Commits · e / os / android_hardware_interfaces

cas/1.1/default/android.hardware.cas@1.1-service-lazy.rc

+1 −0

Original line number	Diff line number	Diff line
		service vendor.cas-hal-1-1 /vendor/bin/hw/android.hardware.cas@1.1-service-lazy
		interface android.hardware.cas@1.0::IMediaCasService default
		interface android.hardware.cas@1.1::IMediaCasService default
		oneshot
		disabled

sensors/1.0/vts/functional/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		@@ -24,7 +24,10 @@ cc_test {
		],
		static_libs: [
		"android.hardware.graphics.allocator@2.0",
		"android.hardware.graphics.allocator@3.0",
		"android.hardware.graphics.mapper@2.0",
		"android.hardware.graphics.mapper@2.1",
		"android.hardware.graphics.mapper@3.0",
		"android.hardware.sensors@1.0",
		"VtsHalSensorsTargetTestUtils",
		],

sensors/2.0/vts/functional/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		@@ -24,7 +24,10 @@ cc_test {
		],
		static_libs: [
		"android.hardware.graphics.allocator@2.0",
		"android.hardware.graphics.allocator@3.0",
		"android.hardware.graphics.mapper@2.0",
		"android.hardware.graphics.mapper@2.1",
		"android.hardware.graphics.mapper@3.0",
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		"libfmq",

sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp

+95 −33

Original line number	Diff line number	Diff line
		@@ -176,19 +176,21 @@ class SensorsHidlTest : public SensorsHidlTestBase {
		// Helper functions
		void activateAllSensors(bool enable);
		std::vector<SensorInfo> getNonOneShotSensors();
		std::vector<SensorInfo> getNonOneShotAndNonSpecialSensors();
		std::vector<SensorInfo> getOneShotSensors();
		std::vector<SensorInfo> getInjectEventSensors();
		int32_t getInvalidSensorHandle();
		bool getDirectChannelSensor(SensorInfo* sensor, SharedMemType* memType, RateLevel* rate);
		void verifyDirectChannel(SharedMemType memType);
		void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
		std::shared_ptr<SensorsTestSharedMemory> mem,
		int32_t* directChannelHandle);
		void verifyRegisterDirectChannel(std::shared_ptr<SensorsTestSharedMemory> mem,
		int32_t* directChannelHandle, bool supportsSharedMemType,
		bool supportsAnyDirectChannel);
		void verifyConfigure(const SensorInfo& sensor, SharedMemType memType,
		int32_t directChannelHandle);
		void verifyUnregisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
		int32_t directChannelHandle);
		int32_t directChannelHandle, bool directChannelSupported);
		void verifyUnregisterDirectChannel(int32_t directChannelHandle, bool directChannelSupported);
		void checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle, RateLevel rateLevel);
		void queryDirectChannelSupport(SharedMemType memType, bool* supportsSharedMemType,
		bool* supportsAnyDirectChannel);
		};

		Return<Result> SensorsHidlTest::activate(int32_t sensorHandle, bool enabled) {
		@@ -257,6 +259,18 @@ std::vector<SensorInfo> SensorsHidlTest::getNonOneShotSensors() {
		return sensors;
		}

		std::vector<SensorInfo> SensorsHidlTest::getNonOneShotAndNonSpecialSensors() {
		std::vector<SensorInfo> sensors;
		for (const SensorInfo& info : getSensorsList()) {
		SensorFlagBits reportMode = extractReportMode(info.flags);
		if (reportMode != SensorFlagBits::ONE_SHOT_MODE &&
		reportMode != SensorFlagBits::SPECIAL_REPORTING_MODE) {
		sensors.push_back(info);
		}
		}
		return sensors;
		}

		std::vector<SensorInfo> SensorsHidlTest::getOneShotSensors() {
		std::vector<SensorInfo> sensors;
		for (const SensorInfo& info : getSensorsList()) {
		@@ -777,7 +791,12 @@ TEST_F(SensorsHidlTest, Batch) {
		activateAllSensors(false /* enable */);
		for (const SensorInfo& sensor : getSensorsList()) {
		// Call batch on inactive sensor
		ASSERT_EQ(batch(sensor.sensorHandle, sensor.minDelay, 0 /* maxReportLatencyNs */),
		// One shot sensors have minDelay set to -1 which is an invalid
		// parameter. Use 0 instead to avoid errors.
		int64_t samplingPeriodNs = extractReportMode(sensor.flags) == SensorFlagBits::ONE_SHOT_MODE
		? 0
		: sensor.minDelay;
		ASSERT_EQ(batch(sensor.sensorHandle, samplingPeriodNs, 0 /* maxReportLatencyNs */),
		Result::OK);

		// Activate the sensor
		@@ -830,9 +849,10 @@ TEST_F(SensorsHidlTest, NoStaleEvents) {
		EventCallback callback;
		getEnvironment()->registerCallback(&callback);

		const std::vector<SensorInfo> sensors = getSensorsList();
		// This test is not valid for one-shot or special-report-mode sensors
		const std::vector<SensorInfo> sensors = getNonOneShotAndNonSpecialSensors();
		milliseconds maxMinDelay(0);
		for (const SensorInfo& sensor : getSensorsList()) {
		for (const SensorInfo& sensor : sensors) {
		milliseconds minDelay = duration_cast<milliseconds>(microseconds(sensor.minDelay));
		maxMinDelay = milliseconds(std::max(maxMinDelay.count(), minDelay.count()));
		}
		@@ -849,10 +869,15 @@ TEST_F(SensorsHidlTest, NoStaleEvents) {
		// Save the last received event for each sensor
		std::map<int32_t, int64_t> lastEventTimestampMap;
		for (const SensorInfo& sensor : sensors) {
		// Some on-change sensors may not report an event without stimulus
		if (extractReportMode(sensor.flags) != SensorFlagBits::ON_CHANGE_MODE) {
		ASSERT_GE(callback.getEvents(sensor.sensorHandle).size(), 1);
		}
		if (callback.getEvents(sensor.sensorHandle).size() >= 1) {
		lastEventTimestampMap[sensor.sensorHandle] =
		callback.getEvents(sensor.sensorHandle).back().timestamp;
		}
		}

		// Allow some time to pass, reset the callback, then reactivate the sensors
		usleep(duration_cast<microseconds>(kOneSecond + (5 * maxMinDelay)).count());
		@@ -862,6 +887,14 @@ TEST_F(SensorsHidlTest, NoStaleEvents) {
		activateAllSensors(false);

		for (const SensorInfo& sensor : sensors) {
		// Skip sensors that did not previously report an event
		if (lastEventTimestampMap.find(sensor.sensorHandle) == lastEventTimestampMap.end()) {
		continue;
		}
		// Skip on-change sensors that do not consistently report an initial event
		if (callback.getEvents(sensor.sensorHandle).size() < 1) {
		continue;
		}
		// Ensure that the first event received is not stale by ensuring that its timestamp is
		// sufficiently different from the previous event
		const Event newEvent = callback.getEvents(sensor.sensorHandle).front();
		@@ -878,21 +911,43 @@ void SensorsHidlTest::checkRateLevel(const SensorInfo& sensor, int32_t directCha
		[&](Result result, int32_t reportToken) {
		if (isDirectReportRateSupported(sensor, rateLevel)) {
		ASSERT_EQ(result, Result::OK);
		if (rateLevel != RateLevel::STOP) {
		ASSERT_GT(reportToken, 0);
		}
		} else {
		ASSERT_EQ(result, Result::BAD_VALUE);
		}
		});
		}

		void SensorsHidlTest::verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
		std::shared_ptr<SensorsTestSharedMemory> mem,
		int32_t* directChannelHandle) {
		void SensorsHidlTest::queryDirectChannelSupport(SharedMemType memType, bool* supportsSharedMemType,
		bool* supportsAnyDirectChannel) {
		*supportsSharedMemType = false;
		*supportsAnyDirectChannel = false;
		for (const SensorInfo& curSensor : getSensorsList()) {
		if (isDirectChannelTypeSupported(curSensor, memType)) {
		*supportsSharedMemType = true;
		}
		if (isDirectChannelTypeSupported(curSensor, SharedMemType::ASHMEM) \|\|
		isDirectChannelTypeSupported(curSensor, SharedMemType::GRALLOC)) {
		*supportsAnyDirectChannel = true;
		}

		if (supportsSharedMemType && supportsAnyDirectChannel) {
		break;
		}
		}
		}

		void SensorsHidlTest::verifyRegisterDirectChannel(std::shared_ptr<SensorsTestSharedMemory> mem,
		int32_t* directChannelHandle,
		bool supportsSharedMemType,
		bool supportsAnyDirectChannel) {
		char* buffer = mem->getBuffer();
		memset(buffer, 0xff, mem->getSize());

		registerDirectChannel(mem->getSharedMemInfo(), [&](Result result, int32_t channelHandle) {
		if (isDirectChannelTypeSupported(sensor, memType)) {
		if (supportsSharedMemType) {
		ASSERT_EQ(result, Result::OK);
		ASSERT_GT(channelHandle, 0);

		@@ -901,7 +956,9 @@ void SensorsHidlTest::verifyRegisterDirectChannel(const SensorInfo& sensor, Shar
		ASSERT_EQ(buffer[i], 0x00);
		}
		} else {
		ASSERT_EQ(result, Result::INVALID_OPERATION);
		Result expectedResult =
		supportsAnyDirectChannel ? Result::BAD_VALUE : Result::INVALID_OPERATION;
		ASSERT_EQ(result, expectedResult);
		ASSERT_EQ(channelHandle, -1);
		}
		*directChannelHandle = channelHandle;
		@@ -909,7 +966,7 @@ void SensorsHidlTest::verifyRegisterDirectChannel(const SensorInfo& sensor, Shar
		}

		void SensorsHidlTest::verifyConfigure(const SensorInfo& sensor, SharedMemType memType,
		int32_t directChannelHandle) {
		int32_t directChannelHandle, bool supportsAnyDirectChannel) {
		if (isDirectChannelTypeSupported(sensor, memType)) {
		// Verify that each rate level is properly supported
		checkRateLevel(sensor, directChannelHandle, RateLevel::NORMAL);
		@@ -925,22 +982,22 @@ void SensorsHidlTest::verifyConfigure(const SensorInfo& sensor, SharedMemType me
		-1 /* sensorHandle */, directChannelHandle, RateLevel::STOP,
		[](Result result, int32_t /* reportToken */) { ASSERT_EQ(result, Result::OK); });
		} else {
		// Direct channel is not supported for this SharedMemType
		// directChannelHandle will be -1 here, HAL should either reject it as a bad value if there
		// is some level of direct channel report, otherwise return INVALID_OPERATION if direct
		// channel is not supported at all
		Result expectedResult =
		supportsAnyDirectChannel ? Result::BAD_VALUE : Result::INVALID_OPERATION;
		configDirectReport(sensor.sensorHandle, directChannelHandle, RateLevel::NORMAL,
		[](Result result, int32_t /* reportToken */) {
		ASSERT_EQ(result, Result::INVALID_OPERATION);
		[expectedResult](Result result, int32_t /* reportToken */) {
		ASSERT_EQ(result, expectedResult);
		});
		}
		}

		void SensorsHidlTest::verifyUnregisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
		int32_t directChannelHandle) {
		Result result = unregisterDirectChannel(directChannelHandle);
		if (isDirectChannelTypeSupported(sensor, memType)) {
		ASSERT_EQ(result, Result::OK);
		} else {
		ASSERT_EQ(result, Result::INVALID_OPERATION);
		}
		void SensorsHidlTest::verifyUnregisterDirectChannel(int32_t directChannelHandle,
		bool supportsAnyDirectChannel) {
		Result expectedResult = supportsAnyDirectChannel ? Result::OK : Result::INVALID_OPERATION;
		ASSERT_EQ(unregisterDirectChannel(directChannelHandle), expectedResult);
		}

		void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) {
		@@ -951,11 +1008,16 @@ void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) {
		SensorsTestSharedMemory::create(memType, kMemSize));
		ASSERT_NE(mem, nullptr);

		bool supportsSharedMemType;
		bool supportsAnyDirectChannel;
		queryDirectChannelSupport(memType, &supportsSharedMemType, &supportsAnyDirectChannel);

		for (const SensorInfo& sensor : getSensorsList()) {
		int32_t directChannelHandle = 0;
		verifyRegisterDirectChannel(sensor, memType, mem, &directChannelHandle);
		verifyConfigure(sensor, memType, directChannelHandle);
		verifyUnregisterDirectChannel(sensor, memType, directChannelHandle);
		verifyRegisterDirectChannel(mem, &directChannelHandle, supportsSharedMemType,
		supportsAnyDirectChannel);
		verifyConfigure(sensor, memType, directChannelHandle, supportsAnyDirectChannel);
		verifyUnregisterDirectChannel(directChannelHandle, supportsAnyDirectChannel);
		}
		}

sensors/common/vts/utils/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		@@ -31,7 +31,10 @@ cc_library_static {
		],
		static_libs: [
		"android.hardware.graphics.allocator@2.0",
		"android.hardware.graphics.allocator@3.0",
		"android.hardware.graphics.mapper@2.0",
		"android.hardware.graphics.mapper@2.1",
		"android.hardware.graphics.mapper@3.0",
		"android.hardware.sensors@1.0",
		"VtsHalHidlTargetTestBase",
		],