diff --git a/modules/camera/3_4/Android.mk b/modules/camera/3_4/Android.mk
index 140e73b..bf888be 100644
--- a/modules/camera/3_4/Android.mk
+++ b/modules/camera/3_4/Android.mk
@@ -52,7 +52,6 @@
 
 v4l2_test_files := \
   format_metadata_factory_test.cpp \
-  metadata/control_factory_test.cpp \
   metadata/control_test.cpp \
   metadata/enum_converter_test.cpp \
   metadata/ignored_control_delegate_test.cpp \
@@ -60,9 +59,11 @@
   metadata/menu_control_options_test.cpp \
   metadata/metadata_test.cpp \
   metadata/no_effect_control_delegate_test.cpp \
+  metadata/partial_metadata_factory_test.cpp \
   metadata/property_test.cpp \
   metadata/ranged_converter_test.cpp \
   metadata/slider_control_options_test.cpp \
+  metadata/state_test.cpp \
   metadata/tagged_control_delegate_test.cpp \
   metadata/tagged_control_options_test.cpp \
   metadata/v4l2_control_delegate_test.cpp \
diff --git a/modules/camera/3_4/format_metadata_factory.cpp b/modules/camera/3_4/format_metadata_factory.cpp
index 83cf5cc..673477b 100644
--- a/modules/camera/3_4/format_metadata_factory.cpp
+++ b/modules/camera/3_4/format_metadata_factory.cpp
@@ -17,6 +17,8 @@
 #include "format_metadata_factory.h"
 
 #include "metadata/array_vector.h"
+#include "metadata/partial_metadata_factory.h"
+#include "metadata/property.h"
 
 namespace v4l2_camera_hal {
 
diff --git a/modules/camera/3_4/format_metadata_factory.h b/modules/camera/3_4/format_metadata_factory.h
index 0c6ae32..4cf5952 100644
--- a/modules/camera/3_4/format_metadata_factory.h
+++ b/modules/camera/3_4/format_metadata_factory.h
@@ -22,9 +22,7 @@
 #include <set>
 
 #include "common.h"
-#include "metadata/control_factory.h"
 #include "metadata/metadata_common.h"
-#include "metadata/property.h"
 #include "v4l2_wrapper.h"
 
 namespace v4l2_camera_hal {
diff --git a/modules/camera/3_4/metadata/control_factory.h b/modules/camera/3_4/metadata/partial_metadata_factory.h
similarity index 94%
rename from modules/camera/3_4/metadata/control_factory.h
rename to modules/camera/3_4/metadata/partial_metadata_factory.h
index f461cfa..a554ee7 100644
--- a/modules/camera/3_4/metadata/control_factory.h
+++ b/modules/camera/3_4/metadata/partial_metadata_factory.h
@@ -23,6 +23,7 @@
 #include "no_effect_control_delegate.h"
 #include "ranged_converter.h"
 #include "slider_control_options.h"
+#include "state.h"
 #include "tagged_control_delegate.h"
 #include "tagged_control_options.h"
 #include "v4l2_control_delegate.h"
@@ -31,7 +32,11 @@
 
 enum class ControlType { kMenu, kSlider };
 
-// Static functions to create controls. Nullptr is returned on failures.
+// Static functions to create partial metadata. Nullptr is returned on failures.
+
+// FixedState: A state that doesn't change.
+template <typename T>
+static std::unique_ptr<State<T>> FixedState(int32_t tag, T value);
 
 // NoEffectOptionlessControl: A control that accepts any value,
 // and has no effect. A default value is given.
@@ -86,6 +91,17 @@
 // -----------------------------------------------------------------------------
 
 template <typename T>
+std::unique_ptr<State<T>> FixedState(int32_t tag, T value) {
+  HAL_LOG_ENTER();
+
+  // Take advantage of ControlDelegate inheriting from StateDelegate;
+  // This will only expose GetValue, not SetValue, so the default will
+  // always be returned.
+  return std::make_unique<State<T>>(
+      tag, std::make_unique<NoEffectControlDelegate<T>>(value));
+}
+
+template <typename T>
 std::unique_ptr<Control<T>> NoEffectOptionlessControl(int32_t delegate_tag,
                                                       T default_value) {
   HAL_LOG_ENTER();
diff --git a/modules/camera/3_4/metadata/control_factory_test.cpp b/modules/camera/3_4/metadata/partial_metadata_factory_test.cpp
similarity index 84%
rename from modules/camera/3_4/metadata/control_factory_test.cpp
rename to modules/camera/3_4/metadata/partial_metadata_factory_test.cpp
index 9010879..4c4a1b1 100644
--- a/modules/camera/3_4/metadata/control_factory_test.cpp
+++ b/modules/camera/3_4/metadata/partial_metadata_factory_test.cpp
@@ -19,9 +19,9 @@
 #include <gtest/gtest.h>
 
 #include "../v4l2_wrapper_mock.h"
-#include "control_factory.h"
 #include "converter_interface_mock.h"
 #include "metadata_common.h"
+#include "partial_metadata_factory.h"
 #include "test_common.h"
 
 using testing::AtMost;
@@ -33,7 +33,7 @@
 
 namespace v4l2_camera_hal {
 
-class ControlFactoryTest : public Test {
+class PartialMetadataFactoryTest : public Test {
  protected:
   virtual void SetUp() {
     mock_device_.reset(new V4L2WrapperMock());
@@ -43,7 +43,7 @@
     control_.reset();
   }
 
-  virtual void ExpectTags() {
+  virtual void ExpectControlTags() {
     ASSERT_EQ(control_->StaticTags().size(), 1);
     EXPECT_EQ(control_->StaticTags()[0], options_tag_);
     ASSERT_EQ(control_->ControlTags().size(), 1);
@@ -52,7 +52,7 @@
     EXPECT_EQ(control_->DynamicTags()[0], delegate_tag_);
   }
 
-  virtual void ExpectOptions(const std::vector<uint8_t>& options) {
+  virtual void ExpectControlOptions(const std::vector<uint8_t>& options) {
     // Options should be available.
     android::CameraMetadata metadata;
     ASSERT_EQ(control_->PopulateStaticFields(&metadata), 0);
@@ -60,7 +60,7 @@
     ExpectMetadataEq(metadata, options_tag_, options);
   }
 
-  virtual void ExpectValue(uint8_t value) {
+  virtual void ExpectControlValue(uint8_t value) {
     android::CameraMetadata metadata;
     ASSERT_EQ(control_->PopulateDynamicFields(&metadata), 0);
     EXPECT_EQ(metadata.entryCount(), 1);
@@ -77,63 +77,78 @@
       ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES;
 };
 
-TEST_F(ControlFactoryTest, NoEffectMenu) {
+TEST_F(PartialMetadataFactoryTest, FixedState) {
+  uint8_t value = 13;
+  std::unique_ptr<State<uint8_t>> state = FixedState(delegate_tag_, value);
+
+  ASSERT_EQ(state->StaticTags().size(), 0);
+  ASSERT_EQ(state->ControlTags().size(), 0);
+  ASSERT_EQ(state->DynamicTags().size(), 1);
+  EXPECT_EQ(state->DynamicTags()[0], delegate_tag_);
+
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state->PopulateDynamicFields(&metadata), 0);
+  EXPECT_EQ(metadata.entryCount(), 1);
+  ExpectMetadataEq(metadata, delegate_tag_, value);
+}
+
+TEST_F(PartialMetadataFactoryTest, NoEffectMenu) {
   std::vector<uint8_t> test_options = {9, 8, 12};
   control_ =
       NoEffectMenuControl<uint8_t>(delegate_tag_, options_tag_, test_options);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Options should be available.
-  ExpectOptions(test_options);
+  ExpectControlOptions(test_options);
   // Default value should be test_options[0].
-  ExpectValue(test_options[0]);
+  ExpectControlValue(test_options[0]);
 }
 
-TEST_F(ControlFactoryTest, NoEffectGenericMenu) {
+TEST_F(PartialMetadataFactoryTest, NoEffectGenericMenu) {
   uint8_t default_val = 9;
   control_ = NoEffectControl<uint8_t>(
       ControlType::kMenu, delegate_tag_, options_tag_, default_val);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Options should be available.
-  ExpectOptions({default_val});
+  ExpectControlOptions({default_val});
   // |default_val| should be default option.
-  ExpectValue(default_val);
+  ExpectControlValue(default_val);
 }
 
-TEST_F(ControlFactoryTest, NoEffectSlider) {
+TEST_F(PartialMetadataFactoryTest, NoEffectSlider) {
   std::vector<uint8_t> test_range = {9, 12};
   control_ = NoEffectSliderControl<uint8_t>(
       delegate_tag_, options_tag_, test_range[0], test_range[1]);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Single option should be available.
-  ExpectOptions(test_range);
+  ExpectControlOptions(test_range);
   // Default value should be the minimum (test_range[0]).
-  ExpectValue(test_range[0]);
+  ExpectControlValue(test_range[0]);
 }
 
-TEST_F(ControlFactoryTest, NoEffectGenericSlider) {
+TEST_F(PartialMetadataFactoryTest, NoEffectGenericSlider) {
   uint8_t default_val = 9;
   control_ = NoEffectControl<uint8_t>(
       ControlType::kSlider, delegate_tag_, options_tag_, default_val);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Range containing only |default_val| should be available.
-  ExpectOptions({default_val, default_val});
+  ExpectControlOptions({default_val, default_val});
   // |default_val| should be default option.
-  ExpectValue(default_val);
+  ExpectControlValue(default_val);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryQueryFail) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryFail) {
   int control_id = 55;
   // Should query the device.
   EXPECT_CALL(*mock_device_, QueryControl(control_id, _)).WillOnce(Return(-1));
@@ -147,7 +162,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryQueryBadType) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryBadType) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_CTRL_CLASS;
@@ -164,7 +179,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryQueryBadRange) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryBadRange) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_MENU;
@@ -183,7 +198,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryTypeRequestMenuMismatch) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryTypeRequestMenuMismatch) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_INTEGER;
@@ -207,7 +222,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryTypeRequestSliderMismatch) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryTypeRequestSliderMismatch) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_MENU;
@@ -231,7 +246,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryMenu) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryMenu) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_MENU;
@@ -262,11 +277,11 @@
                                   mock_converter_);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
-  ExpectOptions(expected_options);
+  ExpectControlTags();
+  ExpectControlOptions(expected_options);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryMenuConversionFail) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryMenuConversionFail) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_MENU;
@@ -289,7 +304,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryMenuNoConversions) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryMenuNoConversions) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_MENU;
@@ -313,7 +328,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryInteger) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryInteger) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_INTEGER;
@@ -342,8 +357,8 @@
                                   mock_converter_);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
-  ExpectOptions(expected_options);
+  ExpectControlTags();
+  ExpectControlOptions(expected_options);
 
   // Should be fitting converted values to steps.
   uint8_t set_val = 10;
@@ -357,7 +372,7 @@
   EXPECT_EQ(control_->SetRequestValues(metadata), 0);
 }
 
-TEST_F(ControlFactoryTest, V4L2FactoryIntegerFailedConversion) {
+TEST_F(PartialMetadataFactoryTest, V4L2FactoryIntegerFailedConversion) {
   int control_id = 55;
   v4l2_query_ext_ctrl query_result;
   query_result.type = V4L2_CTRL_TYPE_INTEGER;
@@ -380,7 +395,7 @@
   ASSERT_EQ(control_, nullptr);
 }
 
-TEST_F(ControlFactoryTest, V4L2FallbackMenu) {
+TEST_F(PartialMetadataFactoryTest, V4L2FallbackMenu) {
   uint8_t default_val = 9;
   int control_id = 55;
 
@@ -397,15 +412,15 @@
                                            default_val);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Options should be available.
-  ExpectOptions({default_val});
+  ExpectControlOptions({default_val});
   // |default_val| should be default option.
-  ExpectValue(default_val);
+  ExpectControlValue(default_val);
 }
 
-TEST_F(ControlFactoryTest, V4L2FallbackSlider) {
+TEST_F(PartialMetadataFactoryTest, V4L2FallbackSlider) {
   uint8_t default_val = 9;
   int control_id = 55;
 
@@ -422,12 +437,12 @@
                                            default_val);
   ASSERT_NE(control_, nullptr);
 
-  ExpectTags();
+  ExpectControlTags();
 
   // Range containing only |default_val| should be available.
-  ExpectOptions({default_val, default_val});
+  ExpectControlOptions({default_val, default_val});
   // |default_val| should be default option.
-  ExpectValue(default_val);
+  ExpectControlValue(default_val);
 }
 
 }  // namespace v4l2_camera_hal
diff --git a/modules/camera/3_4/metadata/state.h b/modules/camera/3_4/metadata/state.h
new file mode 100644
index 0000000..54f66e4
--- /dev/null
+++ b/modules/camera/3_4/metadata/state.h
@@ -0,0 +1,96 @@
+/*
+ * 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_STATE_H_
+#define V4L2_CAMERA_HAL_METADATA_STATE_H_
+
+#include "../common.h"
+#include "metadata_common.h"
+#include "partial_metadata_interface.h"
+#include "state_delegate_interface.h"
+
+namespace v4l2_camera_hal {
+
+// A State is a PartialMetadata that only has a single dynamic value.
+template <typename T>
+class State : public PartialMetadataInterface {
+ public:
+  State(int32_t tag, std::unique_ptr<StateDelegateInterface<T>> delegate)
+      : tag_(tag), delegate_(std::move(delegate)){};
+
+  virtual std::vector<int32_t> StaticTags() const override { return {}; };
+  virtual std::vector<int32_t> ControlTags() const override { return {}; };
+  virtual std::vector<int32_t> DynamicTags() const override { return {tag_}; };
+
+  virtual int PopulateStaticFields(
+      android::CameraMetadata* metadata) const override;
+  virtual int PopulateDynamicFields(
+      android::CameraMetadata* metadata) const override;
+  virtual int PopulateTemplateRequest(
+      int template_type, android::CameraMetadata* metadata) const override;
+  virtual bool SupportsRequestValues(
+      const android::CameraMetadata& metadata) const override;
+  virtual int SetRequestValues(
+      const android::CameraMetadata& metadata) override;
+
+ private:
+  int32_t tag_;
+  std::unique_ptr<StateDelegateInterface<T>> delegate_;
+};
+
+// -----------------------------------------------------------------------------
+
+template <typename T>
+int State<T>::PopulateStaticFields(android::CameraMetadata* metadata) const {
+  HAL_LOG_ENTER();
+  return 0;
+}
+
+template <typename T>
+int State<T>::PopulateDynamicFields(android::CameraMetadata* metadata) const {
+  HAL_LOG_ENTER();
+
+  T value;
+  int res = delegate_->GetValue(&value);
+  if (res) {
+    return res;
+  }
+  return UpdateMetadata(metadata, tag_, value);
+};
+
+template <typename T>
+int State<T>::PopulateTemplateRequest(int template_type,
+                                      android::CameraMetadata* metadata) const {
+  HAL_LOG_ENTER();
+  return 0;
+};
+
+template <typename T>
+bool State<T>::SupportsRequestValues(
+    const android::CameraMetadata& metadata) const {
+  HAL_LOG_ENTER();
+  return true;
+};
+
+template <typename T>
+int State<T>::SetRequestValues(const android::CameraMetadata& metadata) {
+  HAL_LOG_ENTER();
+  return 0;
+};
+
+}  // namespace v4l2_camera_hal
+
+#endif  // V4L2_CAMERA_HAL_METADATA_STATE_H_
diff --git a/modules/camera/3_4/metadata/state_delegate_interface_mock.h b/modules/camera/3_4/metadata/state_delegate_interface_mock.h
new file mode 100644
index 0000000..5064b83
--- /dev/null
+++ b/modules/camera/3_4/metadata/state_delegate_interface_mock.h
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+// Mock for state delegate interfaces.
+
+#ifndef V4L2_CAMERA_HAL_METADATA_STATE_DELEGATE_INTERFACE_MOCK_H_
+#define V4L2_CAMERA_HAL_METADATA_STATE_DELEGATE_INTERFACE_MOCK_H_
+
+#include <gmock/gmock.h>
+
+#include "state_delegate_interface.h"
+
+namespace v4l2_camera_hal {
+
+template <typename T>
+class StateDelegateInterfaceMock : public StateDelegateInterface<T> {
+ public:
+  StateDelegateInterfaceMock(){};
+  MOCK_METHOD1_T(GetValue, int(T*));
+};
+
+}  // namespace v4l2_camera_hal
+
+#endif  // V4L2_CAMERA_HAL_METADATA_CONTROL_DELEGATE_INTERFACE_MOCK_H_
diff --git a/modules/camera/3_4/metadata/state_test.cpp b/modules/camera/3_4/metadata/state_test.cpp
new file mode 100644
index 0000000..5c308bc
--- /dev/null
+++ b/modules/camera/3_4/metadata/state_test.cpp
@@ -0,0 +1,116 @@
+/*
+ * 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 "state.h"
+
+#include <camera/CameraMetadata.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "metadata_common.h"
+#include "state_delegate_interface_mock.h"
+#include "test_common.h"
+
+using testing::AtMost;
+using testing::Expectation;
+using testing::Return;
+using testing::SetArgPointee;
+using testing::Test;
+using testing::_;
+
+namespace v4l2_camera_hal {
+
+class StateTest : public Test {
+ protected:
+  virtual void SetUp() {
+    mock_delegate_.reset(new StateDelegateInterfaceMock<uint8_t>());
+    // Nullify state so an error will be thrown if a test doesn't call
+    // PrepareState.
+    state_.reset();
+  }
+
+  virtual void PrepareState() {
+    // Use this method after all the EXPECT_CALLs to pass ownership of the mocks
+    // to the device.
+    state_.reset(new State<uint8_t>(tag_, std::move(mock_delegate_)));
+  }
+
+  std::unique_ptr<State<uint8_t>> state_;
+  std::unique_ptr<StateDelegateInterfaceMock<uint8_t>> mock_delegate_;
+
+  // Need tag that matches the data type (uint8_t) being passed.
+  const int32_t tag_ = ANDROID_CONTROL_AF_STATE;
+};
+
+TEST_F(StateTest, Tags) {
+  PrepareState();
+  EXPECT_TRUE(state_->StaticTags().empty());
+  EXPECT_TRUE(state_->ControlTags().empty());
+  ASSERT_EQ(state_->DynamicTags().size(), 1);
+  EXPECT_EQ(state_->DynamicTags()[0], tag_);
+}
+
+TEST_F(StateTest, PopulateStatic) {
+  PrepareState();
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state_->PopulateStaticFields(&metadata), 0);
+  EXPECT_TRUE(metadata.isEmpty());
+}
+
+TEST_F(StateTest, PopulateDynamic) {
+  uint8_t expected = 99;
+  EXPECT_CALL(*mock_delegate_, GetValue(_))
+      .WillOnce(DoAll(SetArgPointee<0>(expected), Return(0)));
+
+  PrepareState();
+
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state_->PopulateDynamicFields(&metadata), 0);
+  EXPECT_EQ(metadata.entryCount(), 1);
+  ExpectMetadataEq(metadata, tag_, expected);
+}
+
+TEST_F(StateTest, PopulateDynamicFail) {
+  int err = 123;
+  EXPECT_CALL(*mock_delegate_, GetValue(_)).WillOnce(Return(err));
+
+  PrepareState();
+
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state_->PopulateDynamicFields(&metadata), err);
+}
+
+TEST_F(StateTest, PopulateTemplate) {
+  int template_type = 3;
+  PrepareState();
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state_->PopulateTemplateRequest(template_type, &metadata), 0);
+  EXPECT_TRUE(metadata.isEmpty());
+}
+
+TEST_F(StateTest, SupportsRequest) {
+  PrepareState();
+  android::CameraMetadata metadata;
+  EXPECT_TRUE(state_->SupportsRequestValues(metadata));
+}
+
+TEST_F(StateTest, SetRequest) {
+  PrepareState();
+  android::CameraMetadata metadata;
+  ASSERT_EQ(state_->SetRequestValues(metadata), 0);
+}
+
+}  // namespace v4l2_camera_hal
diff --git a/modules/camera/3_4/v4l2_metadata_factory.cpp b/modules/camera/3_4/v4l2_metadata_factory.cpp
index 6a7220b..412e6d4 100644
--- a/modules/camera/3_4/v4l2_metadata_factory.cpp
+++ b/modules/camera/3_4/v4l2_metadata_factory.cpp
@@ -21,9 +21,9 @@
 #include "common.h"
 #include "format_metadata_factory.h"
 #include "metadata/control.h"
-#include "metadata/control_factory.h"
 #include "metadata/enum_converter.h"
 #include "metadata/metadata_common.h"
+#include "metadata/partial_metadata_factory.h"
 #include "metadata/property.h"
 #include "metadata/scaling_converter.h"
 #include "v4l2_gralloc.h"
@@ -82,6 +82,12 @@
       NoEffectMenuControl<uint8_t>(ANDROID_CONTROL_AF_MODE,
                                    ANDROID_CONTROL_AF_AVAILABLE_MODES,
                                    {ANDROID_CONTROL_AF_MODE_OFF}));
+  // TODO(b/31021522): Should read autofocus state from
+  // V4L2_CID_AUTO_FOCUS_STATUS bitmask. The framework gets a little more
+  // complex than that does; there's a whole state-machine table in
+  // the docs (system/media/camera/docs/docs.html).
+  components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AF_STATE,
+                                        ANDROID_CONTROL_AF_STATE_INACTIVE));
   // TODO(b/31022735): AE & AF triggers.
   components.insert(V4L2ControlOrDefault<uint8_t>(
       ControlType::kMenu,
@@ -136,7 +142,10 @@
     components.insert(std::move(exposure_time));
     components.insert(std::move(sensitivity));
   }
-
+  // Can't get AE status from V4L2.
+  // TODO(b/30510395): If AE mode is OFF, this should switch to INACTIVE.
+  components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AE_STATE,
+                                        ANDROID_CONTROL_AE_STATE_CONVERGED));
   // V4L2 offers multiple white balance interfaces. Try the advanced one before
   // falling
   // back to the simpler version.
@@ -175,6 +184,9 @@
                                {1, ANDROID_CONTROL_AWB_MODE_AUTO}})),
         ANDROID_CONTROL_AWB_MODE_AUTO));
   }
+  // TODO(b/31041577): Handle AWB state machine correctly.
+  components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AWB_STATE,
+                                        ANDROID_CONTROL_AWB_STATE_CONVERGED));
   // TODO(b/31022153): 3A locks.
   components.insert(std::unique_ptr<PartialMetadataInterface>(
       new Property<uint8_t>(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
@@ -245,6 +257,8 @@
   components.insert(
       std::unique_ptr<PartialMetadataInterface>(new Property<uint8_t>(
           ANDROID_FLASH_INFO_AVAILABLE, ANDROID_FLASH_INFO_AVAILABLE_FALSE)));
+  components.insert(FixedState<uint8_t>(ANDROID_FLASH_STATE,
+                                        ANDROID_FLASH_STATE_UNAVAILABLE));
 
   // TODO(30510395): subcomponents of hotpixel.
   // No known V4L2 hot pixel correction. But it might be happening,
@@ -295,6 +309,9 @@
                                  ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
                                  {0}));
   // info.hyperfocalDistance not required for UNCALIBRATED.
+  // No way to know when the lens is moving or not in V4L2.
+  components.insert(
+      FixedState<uint8_t>(ANDROID_LENS_STATE, ANDROID_LENS_STATE_STATIONARY));
   // No known V4L2 lens shading. But it might be happening,
   // so report FAST/HIGH_QUALITY.
   components.insert(NoEffectMenuControl<uint8_t>(
@@ -369,6 +386,9 @@
   components.insert(
       std::unique_ptr<PartialMetadataInterface>(new Property<int32_t>(
           ANDROID_SYNC_MAX_LATENCY, ANDROID_SYNC_MAX_LATENCY_UNKNOWN)));
+  // Never know when controls are synced.
+  components.insert(FixedState<int64_t>(ANDROID_SYNC_FRAME_NUMBER,
+                                        ANDROID_SYNC_FRAME_NUMBER_UNKNOWN));
 
   // TODO(b/31022480): subcomponents of cropping/sensors.
   // Need ANDROID_SCALER_CROP_REGION control support.
@@ -404,6 +424,11 @@
   components.insert(std::unique_ptr<PartialMetadataInterface>(
       new Property<uint8_t>(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
                             ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN)));
+  // TODO(b/29457051): Actually get a timestamp here. For now spoofing as non-0.
+  components.insert(FixedState<int64_t>(ANDROID_SENSOR_TIMESTAMP, 1));
+  // No way to actually get shutter skew from V4L2.
+  components.insert(
+      FixedState<int64_t>(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, 0));
   // No way to actually get orientation from V4L2.
   components.insert(std::unique_ptr<PartialMetadataInterface>(
       new Property<int32_t>(ANDROID_SENSOR_ORIENTATION, 0)));