Merge "Restrict HAL to only required keys for session chars" into main (3c34aeef) · Commits · e / os / android_hardware_interfaces

camera/device/aidl/android/hardware/camera/device/ICameraDevice.aidl

+3 −0

Original line number	Diff line number	Diff line
		@@ -450,6 +450,9 @@ interface ICameraDevice {
		* - ANDROID_CONTROL_ZOOM_RATIO_RANGE
		* - SCALER_AVAILABLE_MAX_DIGITAL_ZOOM
		*
		* No other tags (other than vendor tags) should be set in the characteristics returned from
		* the HAL.
		*
		* A service specific error will be returned on the following conditions
		* INTERNAL_ERROR:
		* The camera device cannot be opened due to an internal

camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp

+7 −3

Original line number	Diff line number	Diff line
		@@ -330,10 +330,14 @@ TEST_P(CameraAidlTest, getSessionCharacteristics) {
		StreamConfiguration config;
		createStreamConfiguration(streams, StreamConfigurationMode::NORMAL_MODE, &config);

		CameraMetadata chars;
		ret = device->getSessionCharacteristics(config, &chars);
		CameraMetadata camera_chars;
		ret = device->getCameraCharacteristics(&camera_chars);
		ASSERT_TRUE(ret.isOk());

		CameraMetadata session_chars;
		ret = device->getSessionCharacteristics(config, &session_chars);
		ASSERT_TRUE(ret.isOk());
		verifySessionCharacteristics(chars);
		verifySessionCharacteristics(session_chars, camera_chars);
		}
		} else {
		ALOGI("getSessionCharacteristics: Test skipped.\n");

camera/provider/aidl/vts/camera_aidl_test.cpp

+72 −41

Original line number	Diff line number	Diff line
		@@ -1916,35 +1916,67 @@ void CameraAidlTest::verifyStreamCombination(const std::shared_ptr<ICameraDevice
		}
		}

		void CameraAidlTest::verifySessionCharacteristics(const CameraMetadata& chars) {
		if (flags::feature_combination_query()) {
		const camera_metadata_t* metadata =
		reinterpret_cast<const camera_metadata_t*>(chars.metadata.data());
		void CameraAidlTest::verifySessionCharacteristics(const CameraMetadata& session_chars,
		const CameraMetadata& camera_chars) {
		if (!flags::feature_combination_query()) {
		return;
		}

		size_t expectedSize = chars.metadata.size();
		int result = validate_camera_metadata_structure(metadata, &expectedSize);
		const camera_metadata_t* session_metadata =
		reinterpret_cast<const camera_metadata_t*>(session_chars.metadata.data());

		const camera_metadata_t* camera_metadata =
		reinterpret_cast<const camera_metadata_t*>(camera_chars.metadata.data());

		size_t expectedSize = session_chars.metadata.size();
		int result = validate_camera_metadata_structure(session_metadata, &expectedSize);
		ASSERT_TRUE((result == 0) \|\| (result == CAMERA_METADATA_VALIDATION_SHIFTED));
		size_t entryCount = get_camera_metadata_entry_count(metadata);
		ASSERT_GT(entryCount, 0u);
		size_t entryCount = get_camera_metadata_entry_count(session_metadata);
		// There should be at least 1 characteristic present:
		// SCALER_MAX_DIGITAL_ZOOM must always be available.
		// ZOOM_RATIO_RANGE must be available if ZOOM_RATIO is supported.
		ASSERT_TRUE(entryCount >= 1);

		camera_metadata_ro_entry entry;
		int retcode = 0;
		float maxDigitalZoom = 1.0;

		retcode = find_camera_metadata_ro_entry(metadata, ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
		&entry);
		// ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM should always be present.
		for (size_t i = 0; i < entryCount; i++) {
		retcode = get_camera_metadata_ro_entry(session_metadata, i, &entry);
		ASSERT_TRUE(retcode == 0);

		std::set<uint32_t> allowed_tags = {ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
		ANDROID_CONTROL_ZOOM_RATIO_RANGE};

		if (contains(allowed_tags, entry.tag)) {
		continue;
		}

		// Other than the ones above, no tags should be allowed apart from vendor tags.
		ASSERT_TRUE(entry.tag >= VENDOR_SECTION_START);
		}

		retcode = find_camera_metadata_ro_entry(session_metadata,
		ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &entry);
		if ((0 == retcode) && (entry.count == 1)) {
		maxDigitalZoom = entry.data.f[0];
		} else {
		ADD_FAILURE() << "Get camera scalerAvailableMaxDigitalZoom failed!";
		}

		retcode = find_camera_metadata_ro_entry(metadata, ANDROID_CONTROL_ZOOM_RATIO_RANGE, &entry);
		retcode = find_camera_metadata_ro_entry(camera_metadata, ANDROID_CONTROL_ZOOM_RATIO_RANGE,
		&entry);
		bool hasZoomRatioRange = (0 == retcode && entry.count == 2);
		if (!hasZoomRatioRange) {
		ALOGI("Skipping the rest of the test as ZOOM_RATIO_RANGE is not in camera characteristics");
		return;
		}

		// Session characteristics must contain zoom_ratio_range if camera characteristics has it.
		retcode = find_camera_metadata_ro_entry(session_metadata, ANDROID_CONTROL_ZOOM_RATIO_RANGE,
		&entry);
		ASSERT_TRUE(0 == retcode && entry.count == 2);

		float minZoomRatio = entry.data.f[0];
		float maxZoomRatio = entry.data.f[1];
		constexpr float FLOATING_POINT_THRESHOLD = 0.00001f;
		@@ -1963,7 +1995,6 @@ void CameraAidlTest::verifySessionCharacteristics(const CameraMetadata& chars) {
		ADD_FAILURE() << "Maximum zoom ratio is less than 1.0!";
		}
		}
		}

		std::vector<ConcurrentCameraIdCombination> CameraAidlTest::getConcurrentDeviceCombinations(
		std::shared_ptr<ICameraProvider>& provider) {

camera/provider/aidl/vts/camera_aidl_test.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -290,7 +290,8 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
		static void verifyStreamCombination(const std::shared_ptr<ICameraDevice>& device,
		const StreamConfiguration& config, bool expectedStatus);

		static void verifySessionCharacteristics(const CameraMetadata& chars);
		static void verifySessionCharacteristics(const CameraMetadata& session_chars,
		const CameraMetadata& camera_chars);

		static void verifyLogicalCameraResult(const camera_metadata_t* staticMetadata,
		const std::vector<uint8_t>& resultMetadata);