Separated v4l2_metadata into two pieces.
v4l2_metadata and metadata/metadata. The previous design did not work
as intended for testing (it incorrectly assumed that a constructor
would call an overridden method of a child class), plus this way
makes more sense.
BUG: 30140438
Change-Id: I1293535932fed6daed766682421b1215739e17dd
TEST: Unit tests pass
diff --git a/modules/camera/3_4/metadata/metadata.cpp b/modules/camera/3_4/metadata/metadata.cpp
new file mode 100644
index 0000000..8867e4d
--- /dev/null
+++ b/modules/camera/3_4/metadata/metadata.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "metadata.h"
+
+#include <camera/CameraMetadata.h>
+
+#include "../common.h"
+
+namespace v4l2_camera_hal {
+
+Metadata::Metadata() { HAL_LOG_ENTER(); }
+
+Metadata::~Metadata() { HAL_LOG_ENTER(); }
+
+void Metadata::AddComponent(
+ std::unique_ptr<PartialMetadataInterface> component) {
+ HAL_LOG_ENTER();
+
+ components_.push_back(std::move(component));
+}
+
+int Metadata::FillStaticMetadata(camera_metadata_t** metadata) {
+ HAL_LOG_ENTER();
+
+ std::vector<int32_t> static_tags;
+ std::vector<int32_t> control_tags;
+ std::vector<int32_t> dynamic_tags;
+ int res = 0;
+
+ for (auto& component : components_) {
+ // Populate the fields.
+ res = component->PopulateStaticFields(metadata);
+ if (res) {
+ // Exit on error.
+ HAL_LOGE("Failed to get all static properties.");
+ return res;
+ }
+
+ // Note what tags the component adds.
+ const std::vector<int32_t>* tags = &component->StaticTags();
+ static_tags.insert(static_tags.end(), tags->begin(), tags->end());
+ tags = &component->ControlTags();
+ control_tags.insert(control_tags.end(), tags->begin(), tags->end());
+ tags = &component->DynamicTags();
+ dynamic_tags.insert(dynamic_tags.end(), tags->begin(), tags->end());
+ }
+
+ // Populate the meta fields.
+ android::CameraMetadata metadata_wrapper(*metadata);
+ static_tags.push_back(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
+ res = metadata_wrapper.update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
+ control_tags.data(), control_tags.size());
+ if (res != android::OK) {
+ HAL_LOGE("Failed to add request keys meta key.");
+ return -ENODEV;
+ }
+ static_tags.push_back(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
+ res = metadata_wrapper.update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
+ dynamic_tags.data(), dynamic_tags.size());
+ if (res != android::OK) {
+ HAL_LOGE("Failed to add result keys meta key.");
+ return -ENODEV;
+ }
+ static_tags.push_back(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+ res = metadata_wrapper.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
+ static_tags.data(), static_tags.size());
+ if (res != android::OK) {
+ HAL_LOGE("Failed to add characteristics keys meta key.");
+ return -ENODEV;
+ }
+
+ *metadata = metadata_wrapper.release();
+ return 0;
+}
+
+bool Metadata::IsValidRequest(const camera_metadata_t* metadata) {
+ HAL_LOG_ENTER();
+
+ // Null means "use previous settings", which are inherently valid.
+ if (metadata == nullptr) return true;
+
+ for (auto& component : components_) {
+ // Check that all components support the values requested of them.
+ bool valid_request = component->SupportsRequestValues(metadata);
+ if (!valid_request) {
+ // Exit early if possible.
+ return false;
+ }
+ }
+
+ return true;
+}
+
+int Metadata::SetRequestSettings(const camera_metadata_t* metadata) {
+ HAL_LOG_ENTER();
+
+ // Null means "use previous settings".
+ if (metadata == nullptr) return 0;
+
+ for (auto& component : components_) {
+ int res = component->SetRequestValues(metadata);
+ if (res) {
+ // Exit early if possible.
+ HAL_LOGE("Failed to set all requested settings.");
+ return res;
+ }
+ }
+
+ return 0;
+}
+
+int Metadata::FillResultMetadata(camera_metadata_t** metadata) {
+ for (auto& component : components_) {
+ int res = component->PopulateDynamicFields(metadata);
+ if (res) {
+ // Exit early if possible.
+ HAL_LOGE("Failed to get all dynamic result fields.");
+ return res;
+ }
+ }
+
+ return 0;
+}
+
+} // namespace v4l2_camera_hal
diff --git a/modules/camera/3_4/metadata/metadata.h b/modules/camera/3_4/metadata/metadata.h
new file mode 100644
index 0000000..d25a040
--- /dev/null
+++ b/modules/camera/3_4/metadata/metadata.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef V4L2_CAMERA_HAL_METADATA_H_
+#define V4L2_CAMERA_HAL_METADATA_H_
+
+#include <hardware/camera3.h>
+
+#include "../common.h"
+#include "partial_metadata_interface.h"
+
+namespace v4l2_camera_hal {
+class Metadata {
+ public:
+ Metadata();
+ virtual ~Metadata();
+
+ int FillStaticMetadata(camera_metadata_t** metadata);
+ bool IsValidRequest(const camera_metadata_t* metadata);
+ int SetRequestSettings(const camera_metadata_t* metadata);
+ int FillResultMetadata(camera_metadata_t** metadata);
+
+ protected:
+ // Helper for the child constructors to fill in metadata components.
+ void AddComponent(std::unique_ptr<PartialMetadataInterface> component);
+
+ private:
+ // The overall metadata is broken down into several distinct pieces.
+ // Note: it is undefined behavior if multiple components share tags.
+ std::vector<std::unique_ptr<PartialMetadataInterface>> components_;
+
+ friend class MetadataTest;
+
+ DISALLOW_COPY_AND_ASSIGN(Metadata);
+};
+
+} // namespace v4l2_camera_hal
+
+#endif // V4L2_CAMERA_HAL_V4L2_METADATA_H_
diff --git a/modules/camera/3_4/metadata/metadata_test.cpp b/modules/camera/3_4/metadata/metadata_test.cpp
new file mode 100644
index 0000000..d7da553
--- /dev/null
+++ b/modules/camera/3_4/metadata/metadata_test.cpp
@@ -0,0 +1,277 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "metadata.h"
+
+#include <memory>
+#include <set>
+#include <vector>
+
+#include <camera/CameraMetadata.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "metadata/partial_metadata_interface_mock.h"
+
+using testing::AtMost;
+using testing::Return;
+using testing::ReturnRef;
+using testing::Test;
+using testing::_;
+
+namespace v4l2_camera_hal {
+
+class MetadataTest : public Test {
+ protected:
+ virtual void SetUp() {
+ dut_.reset(new Metadata());
+
+ component1_.reset(new PartialMetadataInterfaceMock());
+ component2_.reset(new PartialMetadataInterfaceMock());
+ }
+
+ // Once the component mocks have had expectations set,
+ // add them to the device under test.
+ virtual void AddComponents() {
+ // Don't mind moving; Gmock/Gtest fails on leaked mocks unless disabled by
+ // runtime flags.
+ dut_->AddComponent(std::move(component1_));
+ dut_->AddComponent(std::move(component2_));
+ }
+
+ virtual void CompareTags(const std::set<int32_t>& expected,
+ const camera_metadata_entry_t& actual) {
+ ASSERT_EQ(expected.size(), actual.count);
+ for (size_t i = 0; i < actual.count; ++i) {
+ EXPECT_NE(expected.find(actual.data.i32[i]), expected.end());
+ }
+ }
+
+ // Device under test.
+ std::unique_ptr<Metadata> dut_;
+ // Mocks.
+ std::unique_ptr<PartialMetadataInterfaceMock> component1_;
+ std::unique_ptr<PartialMetadataInterfaceMock> component2_;
+ // An empty vector to use as necessary.
+ std::vector<int32_t> empty_tags_;
+};
+
+TEST_F(MetadataTest, FillStaticSuccess) {
+ android::CameraMetadata metadata(1);
+ camera_metadata_t* metadata_raw = metadata.release();
+
+ // Should populate all the component static pieces.
+ EXPECT_CALL(*component1_, PopulateStaticFields(_)).WillOnce(Return(0));
+ EXPECT_CALL(*component2_, PopulateStaticFields(_)).WillOnce(Return(0));
+
+ // Should populate the meta keys, by polling each component's keys.
+ std::vector<int32_t> static_tags_1({1, 2});
+ std::vector<int32_t> static_tags_2({3, 4});
+ std::vector<int32_t> control_tags_1({5, 6});
+ std::vector<int32_t> control_tags_2({7, 8});
+ std::vector<int32_t> dynamic_tags_1({9, 10});
+ std::vector<int32_t> dynamic_tags_2({11, 12});
+ EXPECT_CALL(*component1_, StaticTags()).WillOnce(ReturnRef(static_tags_1));
+ EXPECT_CALL(*component1_, ControlTags()).WillOnce(ReturnRef(control_tags_1));
+ EXPECT_CALL(*component1_, DynamicTags()).WillOnce(ReturnRef(dynamic_tags_1));
+ EXPECT_CALL(*component2_, StaticTags()).WillOnce(ReturnRef(static_tags_2));
+ EXPECT_CALL(*component2_, ControlTags()).WillOnce(ReturnRef(control_tags_2));
+ EXPECT_CALL(*component2_, DynamicTags()).WillOnce(ReturnRef(dynamic_tags_2));
+
+ AddComponents();
+ // Should succeed. If it didn't, no reason to continue checking output.
+ ASSERT_EQ(dut_->FillStaticMetadata(&metadata_raw), 0);
+
+ // Meta keys should be filled correctly.
+ // Note: sets are used here, but it is undefined behavior if
+ // the class has multiple componenets reporting overlapping tags.
+
+ // Get the expected tags = combined tags of all components.
+ std::set<int32_t> static_tags(static_tags_1.begin(), static_tags_1.end());
+ static_tags.insert(static_tags_2.begin(), static_tags_2.end());
+ std::set<int32_t> control_tags(control_tags_1.begin(), control_tags_1.end());
+ control_tags.insert(control_tags_2.begin(), control_tags_2.end());
+ std::set<int32_t> dynamic_tags(dynamic_tags_1.begin(), dynamic_tags_1.end());
+ dynamic_tags.insert(dynamic_tags_2.begin(), dynamic_tags_2.end());
+
+ // Static tags includes not only all component static tags, but also
+ // the meta AVAILABLE_*_KEYS (* = [REQUEST, RESULT, CHARACTERISTICS]).
+ static_tags.emplace(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
+ static_tags.emplace(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
+ static_tags.emplace(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+
+ // Check against what was filled in in the metadata.
+ metadata.acquire(metadata_raw);
+ CompareTags(static_tags,
+ metadata.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS));
+ CompareTags(control_tags,
+ metadata.find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS));
+ CompareTags(dynamic_tags,
+ metadata.find(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS));
+}
+
+TEST_F(MetadataTest, FillStaticFail) {
+ camera_metadata_t* metadata = nullptr;
+ int err = -99;
+ // Order undefined, and may or may not exit early; use AtMost.
+ EXPECT_CALL(*component1_, PopulateStaticFields(_))
+ .Times(AtMost(1))
+ .WillOnce(Return(0));
+ EXPECT_CALL(*component2_, PopulateStaticFields(_)).WillOnce(Return(err));
+
+ // May or may not exit early, may still try to populate meta tags.
+ EXPECT_CALL(*component1_, StaticTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+ EXPECT_CALL(*component1_, ControlTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+ EXPECT_CALL(*component1_, DynamicTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+ EXPECT_CALL(*component2_, StaticTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+ EXPECT_CALL(*component2_, ControlTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+ EXPECT_CALL(*component2_, DynamicTags())
+ .Times(AtMost(1))
+ .WillOnce(ReturnRef(empty_tags_));
+
+ AddComponents();
+ // If any component errors, error should be returned
+ EXPECT_EQ(dut_->FillStaticMetadata(&metadata), err);
+}
+
+TEST_F(MetadataTest, IsValidSuccess) {
+ android::CameraMetadata metadata(1);
+
+ // Should check if all the component request values are valid.
+ EXPECT_CALL(*component1_, SupportsRequestValues(_)).WillOnce(Return(true));
+ EXPECT_CALL(*component2_, SupportsRequestValues(_)).WillOnce(Return(true));
+
+ AddComponents();
+ // Should succeed.
+ // Note: getAndLock is a lock against pointer invalidation, not concurrency,
+ // and unlocks on object destruction.
+ EXPECT_TRUE(dut_->IsValidRequest(metadata.getAndLock()));
+}
+
+TEST_F(MetadataTest, IsValidFail) {
+ android::CameraMetadata metadata(1);
+
+ // Should check if all the component request values are valid.
+ // Order undefined, and may or may not exit early; use AtMost.
+ EXPECT_CALL(*component1_, SupportsRequestValues(_))
+ .Times(AtMost(1))
+ .WillOnce(Return(true));
+ EXPECT_CALL(*component2_, SupportsRequestValues(_)).WillOnce(Return(false));
+
+ AddComponents();
+ // Should fail since one of the components failed.
+ // Note: getAndLock is a lock against pointer invalidation, not concurrency,
+ // and unlocks on object destruction.
+ EXPECT_FALSE(dut_->IsValidRequest(metadata.getAndLock()));
+}
+
+TEST_F(MetadataTest, IsValidNull) {
+ camera_metadata_t* metadata = nullptr;
+
+ // Setting null settings is a special case indicating to use the
+ // previous (valid) settings. As such it is inherently valid.
+ // Should not try to check any components.
+ EXPECT_CALL(*component1_, SupportsRequestValues(_)).Times(0);
+ EXPECT_CALL(*component2_, SupportsRequestValues(_)).Times(0);
+
+ AddComponents();
+ EXPECT_TRUE(dut_->IsValidRequest(metadata));
+}
+
+TEST_F(MetadataTest, SetSettingsSuccess) {
+ android::CameraMetadata metadata(1);
+
+ // Should check if all the components set successfully.
+ EXPECT_CALL(*component1_, SetRequestValues(_)).WillOnce(Return(0));
+ EXPECT_CALL(*component2_, SetRequestValues(_)).WillOnce(Return(0));
+
+ AddComponents();
+ // Should succeed.
+ // Note: getAndLock is a lock against pointer invalidation, not concurrency,
+ // and unlocks on object destruction.
+ EXPECT_EQ(dut_->SetRequestSettings(metadata.getAndLock()), 0);
+}
+
+TEST_F(MetadataTest, SetSettingsFail) {
+ android::CameraMetadata metadata(1);
+ int err = -99;
+
+ // Should check if all the components set successfully.
+ // Order undefined, and may or may not exit early; use AtMost.
+ EXPECT_CALL(*component1_, SetRequestValues(_))
+ .Times(AtMost(1))
+ .WillOnce(Return(0));
+ EXPECT_CALL(*component2_, SetRequestValues(_)).WillOnce(Return(err));
+
+ AddComponents();
+ // Should fail since one of the components failed.
+ // Note: getAndLock is a lock against pointer invalidation, not concurrency,
+ // and unlocks on object destruction.
+ EXPECT_EQ(dut_->SetRequestSettings(metadata.getAndLock()), err);
+}
+
+TEST_F(MetadataTest, SetSettingsNull) {
+ camera_metadata_t* metadata = nullptr;
+
+ // Setting null settings is a special case indicating to use the
+ // previous settings. Should not try to set any components.
+ EXPECT_CALL(*component1_, SetRequestValues(_)).Times(0);
+ EXPECT_CALL(*component2_, SetRequestValues(_)).Times(0);
+
+ AddComponents();
+ // Should succeed.
+ EXPECT_EQ(dut_->SetRequestSettings(metadata), 0);
+}
+
+TEST_F(MetadataTest, FillResultSuccess) {
+ camera_metadata_t* metadata = nullptr;
+
+ // Should check if all the components fill results successfully.
+ EXPECT_CALL(*component1_, PopulateDynamicFields(_)).WillOnce(Return(0));
+ EXPECT_CALL(*component2_, PopulateDynamicFields(_)).WillOnce(Return(0));
+
+ AddComponents();
+ // Should succeed.
+ EXPECT_EQ(dut_->FillResultMetadata(&metadata), 0);
+}
+
+TEST_F(MetadataTest, FillResultFail) {
+ camera_metadata_t* metadata = nullptr;
+ int err = -99;
+
+ // Should check if all the components fill results successfully.
+ // Order undefined, and may or may not exit early; use AtMost.
+ EXPECT_CALL(*component1_, PopulateDynamicFields(_))
+ .Times(AtMost(1))
+ .WillOnce(Return(0));
+ EXPECT_CALL(*component2_, PopulateDynamicFields(_)).WillOnce(Return(err));
+
+ AddComponents();
+ // Should fail since one of the components failed.
+ EXPECT_EQ(dut_->FillResultMetadata(&metadata), err);
+}
+
+} // namespace v4l2_camera_hal