diff --git a/modules/camera/3_4/V4L2Camera.cpp b/modules/camera/3_4/V4L2Camera.cpp
index cb310a7..b3ae4fc 100644
--- a/modules/camera/3_4/V4L2Camera.cpp
+++ b/modules/camera/3_4/V4L2Camera.cpp
@@ -33,6 +33,19 @@
 
 namespace v4l2_camera_hal {
 
+// Helper function for managing metadata.
+static std::vector<int32_t> getMetadataKeys(
+    const camera_metadata_t* metadata) {
+  std::vector<int32_t> keys;
+  size_t num_entries = get_camera_metadata_entry_count(metadata);
+  for (size_t i = 0; i < num_entries; ++i) {
+    camera_metadata_ro_entry_t entry;
+    get_camera_metadata_ro_entry(metadata, i, &entry);
+    keys.push_back(entry.tag);
+  }
+  return keys;
+}
+
 V4L2Camera::V4L2Camera(int id, std::string path)
     : default_camera_hal::Camera(id),
       mDevicePath(std::move(path)),
@@ -95,13 +108,6 @@
 
   android::CameraMetadata info;
 
-  std::vector<int32_t> avail_characteristics_keys;
-
-#define ADD_STATIC_ENTRY(name, varptr, count) \
-  avail_characteristics_keys.push_back(name); \
-  res = info.update(name, varptr, count); \
-  if (res != android::OK) return res
-
   // Static metadata characteristics from /system/media/camera/docs/docs.html.
 
   /* android.colorCorrection. */
@@ -111,70 +117,118 @@
   uint8_t avail_aberration_modes[] = {
     ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST,
     ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY};
-  ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
-                   avail_aberration_modes, ARRAY_SIZE(avail_aberration_modes));
+  res = info.update(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
+                    avail_aberration_modes, ARRAY_SIZE(avail_aberration_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.control. */
 
   /*   3As */
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-                   mAeAntibandingModes.data(), mAeAntibandingModes.size());
+  res = info.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
+                    mAeAntibandingModes.data(), mAeAntibandingModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_MODES,
-                   mAeModes.data(), mAeModes.size());
+  res = info.update(ANDROID_CONTROL_AE_AVAILABLE_MODES,
+                    mAeModes.data(), mAeModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // Flatten mFpsRanges.
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-                   mFpsRanges.data(), mFpsRanges.total_num_elements());
+  res = info.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
+                    mFpsRanges.data(), mFpsRanges.total_num_elements());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
-                   mAeCompensationRange.data(), mAeCompensationRange.size());
+  res = info.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
+                    mAeCompensationRange.data(), mAeCompensationRange.size());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP,
-                   &mAeCompensationStep, 1);
+  res = info.update(ANDROID_CONTROL_AE_COMPENSATION_STEP,
+                    &mAeCompensationStep, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES,
-                   mAfModes.data(), mAfModes.size());
+  res = info.update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
+                    mAfModes.data(), mAfModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
-                   mAwbModes.data(), mAwbModes.size());
+  res = info.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
+                    mAwbModes.data(), mAwbModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // Couldn't find any V4L2 support for regions, though maybe it's out there.
   int32_t max_regions[] = {/*AE*/ 0,/*AWB*/ 0,/*AF*/ 0};
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_MAX_REGIONS,
-                   max_regions, ARRAY_SIZE(max_regions));
+  res = info.update(ANDROID_CONTROL_MAX_REGIONS,
+                    max_regions, ARRAY_SIZE(max_regions));
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
-                   &mAeLockAvailable, 1);
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
-                   &mAwbLockAvailable, 1);
+  res = info.update(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
+                    &mAeLockAvailable, 1);
+  if (res != android::OK) {
+    return res;
+  }
+  res = info.update(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
+                    &mAwbLockAvailable, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Scene modes. */
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
-                   mSceneModes.data(), mSceneModes.size());
+  res = info.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
+                    mSceneModes.data(), mSceneModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // A 3-tuple of AE, AWB, AF overrides for each scene mode.
   // Ignored for DISABLED, FACE_PRIORITY and FACE_PRIORITY_LOW_LIGHT.
   uint8_t scene_mode_overrides[] = {
     /*SCENE_MODE_DISABLED*/ /*AE*/0, /*AW*/0, /*AF*/0};
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
-                   scene_mode_overrides, ARRAY_SIZE(scene_mode_overrides));
+  res = info.update(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
+                    scene_mode_overrides, ARRAY_SIZE(scene_mode_overrides));
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Top level 3A/Scenes switch. */
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES,
-                   mControlModes.data(), mControlModes.size());
+  res = info.update(ANDROID_CONTROL_AVAILABLE_MODES,
+                    mControlModes.data(), mControlModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Other android.control configuration. */
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
-                   mVideoStabilizationModes.data(),
-                   mVideoStabilizationModes.size());
+  res = info.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
+                    mVideoStabilizationModes.data(),
+                    mVideoStabilizationModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_EFFECTS,
-                   mEffects.data(), mEffects.size());
+  res = info.update(ANDROID_CONTROL_AVAILABLE_EFFECTS,
+                    mEffects.data(), mEffects.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS only necessary
   // for devices supporting CONSTRAINED_HIGH_SPEED_VIDEO,
@@ -190,13 +244,19 @@
   // either way it's fine to list.
   uint8_t avail_edge_modes[] = {
     ANDROID_EDGE_MODE_FAST};
-  ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
-                   avail_edge_modes, ARRAY_SIZE(avail_edge_modes));
+  res = info.update(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
+                    avail_edge_modes, ARRAY_SIZE(avail_edge_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.flash. */
 
-  ADD_STATIC_ENTRY(ANDROID_FLASH_INFO_AVAILABLE,
-                   &mFlashAvailable, 1);
+  res = info.update(ANDROID_FLASH_INFO_AVAILABLE,
+                    &mFlashAvailable, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // info.chargeDuration, color.Temperature, maxEnergy marked FUTURE.
 
@@ -207,8 +267,11 @@
   uint8_t avail_hot_pixel_modes[] = {
     ANDROID_HOT_PIXEL_MODE_FAST,
     ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY};
-  ADD_STATIC_ENTRY(ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
-                   avail_hot_pixel_modes, ARRAY_SIZE(avail_hot_pixel_modes));
+  res = info.update(ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
+                    avail_hot_pixel_modes, ARRAY_SIZE(avail_hot_pixel_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.jpeg. */
 
@@ -217,54 +280,84 @@
   // since V4L2 doesn't actually allow for thumbnail size control.
   int32_t thumbnail_sizes[] = {
     0, 0};
-  ADD_STATIC_ENTRY(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-                   thumbnail_sizes, ARRAY_SIZE(thumbnail_sizes));
+  res = info.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
+                    thumbnail_sizes, ARRAY_SIZE(thumbnail_sizes));
+  if (res != android::OK) {
+    return res;
+  }
 
   // V4L2 doesn't support querying this, so we generously assume up to 3 MB.
   int32_t max_jpeg_size = 3000000;
-  ADD_STATIC_ENTRY(ANDROID_JPEG_MAX_SIZE,
-                   &max_jpeg_size, 1);
+  res = info.update(ANDROID_JPEG_MAX_SIZE,
+                    &max_jpeg_size, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.lens. */
 
   /*   Misc. lens control. */
 
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
-                   &mAperture, 1);
+  res = info.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
+                    &mAperture, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
-                   &mFilterDensity, 1);
+  res = info.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
+                    &mFilterDensity, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
-                   mOpticalStabilizationModes.data(),
-                   mOpticalStabilizationModes.size());
+  res = info.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
+                    mOpticalStabilizationModes.data(),
+                    mOpticalStabilizationModes.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // No known V4L2 shading map info.
   int32_t shading_map_size[] = {1, 1};
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_SHADING_MAP_SIZE,
-                   shading_map_size, ARRAY_SIZE(shading_map_size));
+  res = info.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE,
+                    shading_map_size, ARRAY_SIZE(shading_map_size));
+  if (res != android::OK) {
+    return res;
+  }
 
   // All V4L2 devices are considered to be external facing.
   uint8_t facing = ANDROID_LENS_FACING_EXTERNAL;
-  ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &facing, 1);
+  res = info.update(ANDROID_LENS_FACING, &facing, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Zoom/Focus. */
 
   // No way to actually get the focal length in V4L2, but it's a required key,
   // so we just fake it.
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
-                   &mFocalLength, 1);
+  res = info.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
+                    &mFocalLength, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // V4L2 focal units do not correspond to a particular physical unit.
   uint8_t focus_calibration =
       ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED;
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
-                   &focus_calibration, 1);
+  res = info.update(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
+                    &focus_calibration, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // info.hyperfocalDistance not required for UNCALIBRATED.
 
-  ADD_STATIC_ENTRY(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
-                   &mFocusDistance, 1);
+  res = info.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
+                    &mFocusDistance, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Depth. */
 
@@ -279,9 +372,12 @@
   // Unable to control noise reduction in V4L2 devices,
   // but FAST is allowed to be the same as OFF.
   uint8_t avail_noise_reduction_modes[] = {ANDROID_NOISE_REDUCTION_MODE_FAST};
-  ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
-                   avail_noise_reduction_modes,
-                   ARRAY_SIZE(avail_noise_reduction_modes));
+  res = info.update(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
+                    avail_noise_reduction_modes,
+                    ARRAY_SIZE(avail_noise_reduction_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.request. */
 
@@ -289,16 +385,22 @@
   // for LIMITED devices.
   int32_t max_num_output_streams[] = {
     /*Raw*/0, /*YUV*/2, /*JPEG*/1};
-  ADD_STATIC_ENTRY(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
-                   max_num_output_streams, ARRAY_SIZE(max_num_output_streams));
+  res = info.update(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
+                    max_num_output_streams, ARRAY_SIZE(max_num_output_streams));
+  if (res != android::OK) {
+    return res;
+  }
 
   // Reprocessing not supported, so no maxNumInputStreams.
 
   // No way to know for V4L2, so fake with max allowable latency.
   // Doesn't mean much without per-frame controls.
   uint8_t pipeline_max_depth = 4;
-  ADD_STATIC_ENTRY(ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
-                   &pipeline_max_depth, 1);
+  res = info.update(ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
+                    &pipeline_max_depth, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // Partial results not supported; partialResultCount defaults to 1.
 
@@ -308,56 +410,89 @@
 
   /*   Cropping. */
 
-  ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
-                   &mMaxZoom, 1);
+  res = info.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
+                    &mMaxZoom, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_SCALER_CROPPING_TYPE, &mCropType, 1);
+  res = info.update(ANDROID_SCALER_CROPPING_TYPE, &mCropType, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Streams. */
 
   // availableInputOutputFormatsMap only required for reprocessing capability.
 
   // Flatten mStreamConfigs.
-  ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
-                   mStreamConfigs.data(),
-                   mStreamConfigs.total_num_elements());
+  res = info.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
+                    mStreamConfigs.data(),
+                    mStreamConfigs.total_num_elements());
+  if (res != android::OK) {
+    return res;
+  }
 
   // Flatten mMinFrameDurations.
-  ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
-                   mMinFrameDurations.data(),
-                   mMinFrameDurations.total_num_elements());
+  res = info.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
+                    mMinFrameDurations.data(),
+                    mMinFrameDurations.total_num_elements());
+  if (res != android::OK) {
+    return res;
+  }
 
   // Flatten mStallDurations.
-  ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
-                   mStallDurations.data(),
-                   mStallDurations.total_num_elements());
+  res = info.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
+                    mStallDurations.data(),
+                    mStallDurations.total_num_elements());
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.sensor. */
 
   /*   Sizes. */
 
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
-                   mPixelArraySize.data(), mPixelArraySize.size());
+  res = info.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
+                    mPixelArraySize.data(), mPixelArraySize.size());
+  if (res != android::OK) {
+    return res;
+  }
   // No V4L2 way to differentiate active vs. inactive parts of the rectangle.
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
-                   mPixelArraySize.data(), mPixelArraySize.size());
+  res = info.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
+                    mPixelArraySize.data(), mPixelArraySize.size());
+  if (res != android::OK) {
+    return res;
+  }
 
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
-                   mPhysicalSize.data(), mPhysicalSize.size());
+  res = info.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
+                    mPhysicalSize.data(), mPhysicalSize.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   Misc sensor information. */
 
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
-                   &mMaxFrameDuration, 1);
+  res = info.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
+                    &mMaxFrameDuration, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // HAL uses BOOTTIME timestamps.
   // TODO(b/29457051): make sure timestamps are consistent throughout the HAL.
   uint8_t timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
-                   &timestamp_source, 1);
+  res = info.update(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
+                    &timestamp_source, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // As in initDeviceInfo, no way to actually get orientation.
-  ADD_STATIC_ENTRY(ANDROID_SENSOR_ORIENTATION, &mOrientation, 1);
+  res = info.update(ANDROID_SENSOR_ORIENTATION, &mOrientation, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // availableTestPatternModes just defaults to OFF, which is fine.
 
@@ -386,21 +521,30 @@
   uint8_t avail_shading_modes[] = {
     ANDROID_SHADING_MODE_FAST,
     ANDROID_SHADING_MODE_HIGH_QUALITY};
-  ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES,
-                   avail_shading_modes, ARRAY_SIZE(avail_shading_modes));
+  res = info.update(ANDROID_SHADING_AVAILABLE_MODES,
+                    avail_shading_modes, ARRAY_SIZE(avail_shading_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.statistics */
 
   // Face detection not supported.
   uint8_t avail_face_detect_modes[] = {
     ANDROID_STATISTICS_FACE_DETECT_MODE_OFF};
-  ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
-                   avail_face_detect_modes,
-                   ARRAY_SIZE(avail_face_detect_modes));
+  res = info.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
+                    avail_face_detect_modes,
+                    ARRAY_SIZE(avail_face_detect_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   int32_t max_face_count = 0;
-  ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
-                   &max_face_count, 1);
+  res = info.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
+                    &max_face_count, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // info.histogramBucketCount, info.maxHistogramCount,
   // info.maxSharpnessMapValue, info.sharpnessMapSizemarked FUTURE.
@@ -408,16 +552,22 @@
   // ON only needs to be supported for RAW capable devices.
   uint8_t avail_hot_pixel_map_modes[] = {
     ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF};
-  ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
-                   avail_hot_pixel_map_modes,
-                   ARRAY_SIZE(avail_hot_pixel_map_modes));
+  res = info.update(ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
+                    avail_hot_pixel_map_modes,
+                    ARRAY_SIZE(avail_hot_pixel_map_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   // ON only needs to be supported for RAW capable devices.
   uint8_t avail_lens_shading_map_modes[] = {
     ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF};
-  ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
-                   avail_lens_shading_map_modes,
-                   ARRAY_SIZE(avail_lens_shading_map_modes));
+  res = info.update(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
+                    avail_lens_shading_map_modes,
+                    ARRAY_SIZE(avail_lens_shading_map_modes));
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.tonemap. */
 
@@ -427,7 +577,10 @@
 
   // May or may not have LEDs available.
   if (!mLeds.empty()) {
-    ADD_STATIC_ENTRY(ANDROID_LED_AVAILABLE_LEDS, mLeds.data(), mLeds.size());
+    res = info.update(ANDROID_LED_AVAILABLE_LEDS, mLeds.data(), mLeds.size());
+    if (res != android::OK) {
+      return res;
+    }
   }
 
   /* android.sync. */
@@ -438,8 +591,11 @@
   // really help here either. Could even be that adjusting settings mid-stream
   // blocks in V4L2, and should be avoided.
   int32_t max_latency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
-  ADD_STATIC_ENTRY(ANDROID_SYNC_MAX_LATENCY,
-                   &max_latency, 1);
+  res = info.update(ANDROID_SYNC_MAX_LATENCY,
+                    &max_latency, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.reprocess. */
 
@@ -452,13 +608,19 @@
   /* Capabilities and android.info. */
 
   uint8_t hw_level = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
-  ADD_STATIC_ENTRY(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
-                   &hw_level, 1);
+  res = info.update(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
+                    &hw_level, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t capabilities[] = {
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE};
-  ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
-                   capabilities, ARRAY_SIZE(capabilities));
+  res = info.update(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
+                    capabilities, ARRAY_SIZE(capabilities));
+  if (res != android::OK) {
+    return res;
+  }
 
   // Scan a default request template for included request keys.
   if (!mTemplatesInitialized) {
@@ -467,8 +629,7 @@
       return res;
     }
   }
-  std::vector<int32_t> avail_request_keys;
-  const camera_metadata_t *preview_request = nullptr;
+  const camera_metadata_t* preview_request = nullptr;
   // Search templates from the beginning for a supported one.
   for (uint8_t template_id = 1; template_id < CAMERA3_TEMPLATE_COUNT;
        ++template_id) {
@@ -481,25 +642,38 @@
     HAL_LOGE("No valid templates, can't get request keys.");
     return -ENODEV;
   }
-  size_t num_entries = get_camera_metadata_entry_count(preview_request);
-  for (size_t i = 0; i < num_entries; ++i) {
-    camera_metadata_ro_entry_t entry;
-    get_camera_metadata_ro_entry(preview_request, i, &entry);
-    avail_request_keys.push_back(entry.tag);
+  std::vector<int32_t> avail_request_keys = getMetadataKeys(preview_request);
+  res = info.update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
+                    avail_request_keys.data(), avail_request_keys.size());
+  if (res != android::OK) {
+    return res;
   }
-  ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
-                   avail_request_keys.data(), avail_request_keys.size());
 
   // Result keys will be duplicated from the request, plus a few extras.
   // TODO(b/29335262): additonal available result keys.
   std::vector<int32_t> avail_result_keys(avail_request_keys);
-  ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
-                   avail_result_keys.data(), avail_result_keys.size());
+  res = info.update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
+                    avail_result_keys.data(), avail_result_keys.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   // Last thing, once all the available characteristics have been added.
-  info.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
-              avail_characteristics_keys.data(),
-              avail_characteristics_keys.size());
+  const camera_metadata_t* static_characteristics = info.getAndLock();
+  std::vector<int32_t> avail_characteristics_keys =
+      getMetadataKeys(static_characteristics);
+  res = info.unlock(static_characteristics);
+  if (res != android::OK) {
+    return res;
+  }
+  avail_characteristics_keys.push_back(
+      ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+  res = info.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
+                    avail_characteristics_keys.data(),
+                    avail_characteristics_keys.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   *out = info.release();
   return 0;
@@ -547,22 +721,25 @@
   // Note: static metadata expects all templates/requests
   // to provide values for all supported keys.
 
-  android::CameraMetadata template_metadata;
-#define ADD_REQUEST_ENTRY(name, varptr, count) \
-  res = template_metadata.update(name, varptr, count); \
-  if (res != android::OK) return res
+  android::CameraMetadata base_metadata;
 
   // Start with defaults for all templates.
 
   /* android.colorCorrection. */
 
   uint8_t aberration_mode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
-                    &aberration_mode, 1);
+  res = base_metadata.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
+                             &aberration_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t color_correction_mode = ANDROID_COLOR_CORRECTION_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_COLOR_CORRECTION_MODE,
-                    &color_correction_mode, 1);
+  res = base_metadata.update(ANDROID_COLOR_CORRECTION_MODE,
+                             &color_correction_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // transform and gains are for the unsupported MANUAL_POST_PROCESSING only.
 
@@ -570,27 +747,42 @@
 
   /*   AE. */
   uint8_t ae_antibanding_mode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
-                    &ae_antibanding_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
+                             &ae_antibanding_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // Only matters if AE_MODE = OFF
   int32_t ae_exposure_compensation = 0;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
-                    &ae_exposure_compensation, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
+                             &ae_exposure_compensation, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t ae_lock = ANDROID_CONTROL_AE_LOCK_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_LOCK, &ae_lock, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AE_LOCK, &ae_lock, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t ae_mode = ANDROID_CONTROL_AE_MODE_ON;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_MODE, &ae_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AE_MODE, &ae_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // AE regions not supported.
 
   // FPS set per-template.
 
   uint8_t ae_precapture_trigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
-                    &ae_precapture_trigger, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
+                             &ae_precapture_trigger, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   AF. */
 
@@ -599,7 +791,10 @@
   // AF regions not supported.
 
   uint8_t af_trigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AF_TRIGGER, &af_trigger, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AF_TRIGGER, &af_trigger, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /*   AWB. */
 
@@ -612,25 +807,40 @@
                        ANDROID_CONTROL_AWB_MODE_OFF)) {
     default_awb_mode = ANDROID_CONTROL_AWB_MODE_OFF;
   }
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_AWB_MODE, &default_awb_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_AWB_MODE, &default_awb_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // AWB regions not supported.
 
   /*   Other controls. */
 
   uint8_t effect_mode = ANDROID_CONTROL_EFFECT_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_EFFECT_MODE, &effect_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_EFFECT_MODE, &effect_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t control_mode = ANDROID_CONTROL_MODE_AUTO;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_MODE, &control_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_MODE, &control_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t scene_mode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_SCENE_MODE,
-                    &scene_mode, 1);
+  res = base_metadata.update(ANDROID_CONTROL_SCENE_MODE,
+                             &scene_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t video_stabilization = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
-                    &video_stabilization, 1);
+  res = base_metadata.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
+                             &video_stabilization, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // postRawSensitivityBoost: RAW not supported, leave null.
 
@@ -641,7 +851,10 @@
   /* android.edge. */
 
   uint8_t edge_mode = ANDROID_EDGE_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_EDGE_MODE, &edge_mode, 1);
+  res = base_metadata.update(ANDROID_EDGE_MODE, &edge_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // strength marked FUTURE.
 
@@ -650,58 +863,106 @@
   // firingPower, firingTime marked FUTURE.
 
   uint8_t flash_mode = ANDROID_FLASH_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_FLASH_MODE, &flash_mode, 1);
+  res = base_metadata.update(ANDROID_FLASH_MODE, &flash_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.hotPixel. */
 
   uint8_t hp_mode = ANDROID_HOT_PIXEL_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_HOT_PIXEL_MODE, &hp_mode, 1);
+  res = base_metadata.update(ANDROID_HOT_PIXEL_MODE, &hp_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.jpeg. */
 
   double gps_coords[] = {/*latitude*/0, /*longitude*/0, /*altitude*/0};
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_GPS_COORDINATES, gps_coords, 3);
+  res = base_metadata.update(ANDROID_JPEG_GPS_COORDINATES, gps_coords, 3);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t gps_processing_method[] = "none";
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_GPS_PROCESSING_METHOD,
-                    gps_processing_method, ARRAY_SIZE(gps_processing_method));
+  res = base_metadata.update(ANDROID_JPEG_GPS_PROCESSING_METHOD,
+                             gps_processing_method,
+                             ARRAY_SIZE(gps_processing_method));
+  if (res != android::OK) {
+    return res;
+  }
 
   int64_t gps_timestamp = 0;
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_GPS_TIMESTAMP, &gps_timestamp, 1);
+  res = base_metadata.update(ANDROID_JPEG_GPS_TIMESTAMP, &gps_timestamp, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // JPEG orientation is relative to sensor orientation (mOrientation).
   int32_t jpeg_orientation = 0;
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_ORIENTATION, &jpeg_orientation, 1);
+  res = base_metadata.update(ANDROID_JPEG_ORIENTATION, &jpeg_orientation, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // 1-100, larger is higher quality.
   uint8_t jpeg_quality = 80;
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_QUALITY, &jpeg_quality, 1);
+  res = base_metadata.update(ANDROID_JPEG_QUALITY, &jpeg_quality, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // TODO(b/29580107): If thumbnail quality actually matters/can be adjusted,
   // adjust this.
   uint8_t thumbnail_quality = 80;
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnail_quality, 1);
+  res = base_metadata.update(ANDROID_JPEG_THUMBNAIL_QUALITY,
+                             &thumbnail_quality, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // TODO(b/29580107): Choose a size matching the resolution.
   int32_t thumbnail_size[] = {0, 0};
-  ADD_REQUEST_ENTRY(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnail_size, 2);
+  res = base_metadata.update(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnail_size, 2);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.lens. */
 
   // Fixed values.
-  ADD_REQUEST_ENTRY(ANDROID_LENS_APERTURE, &mAperture, 1);
-  ADD_REQUEST_ENTRY(ANDROID_LENS_FILTER_DENSITY, &mFilterDensity, 1);
-  ADD_REQUEST_ENTRY(ANDROID_LENS_FOCAL_LENGTH, &mFocalLength, 1);
-  ADD_REQUEST_ENTRY(ANDROID_LENS_FOCUS_DISTANCE, &mFocusDistance, 1);
+  res = base_metadata.update(ANDROID_LENS_APERTURE, &mAperture, 1);
+  if (res != android::OK) {
+    return res;
+  }
+  res = base_metadata.update(ANDROID_LENS_FILTER_DENSITY, &mFilterDensity, 1);
+  if (res != android::OK) {
+    return res;
+  }
+  res = base_metadata.update(ANDROID_LENS_FOCAL_LENGTH, &mFocalLength, 1);
+  if (res != android::OK) {
+    return res;
+  }
+  res = base_metadata.update(ANDROID_LENS_FOCUS_DISTANCE, &mFocusDistance, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t optical_stabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
+  res = base_metadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
                     &optical_stabilization, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.noiseReduction. */
 
   uint8_t noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_NOISE_REDUCTION_MODE, &noise_reduction_mode, 1);
+  res = base_metadata.update(ANDROID_NOISE_REDUCTION_MODE,
+                             &noise_reduction_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // strength marked FUTURE.
 
@@ -710,15 +971,21 @@
   // Request Id unused by the HAL for now, and these are just
   // templates, so just fill it in with a dummy.
   int32_t id = 0;
-  ADD_REQUEST_ENTRY(ANDROID_REQUEST_ID, &id, 1);
+  res = base_metadata.update(ANDROID_REQUEST_ID, &id, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // metadataMode marked FUTURE.
 
   /* android.scaler. */
 
   // No cropping by default; use the full active array.
-  ADD_REQUEST_ENTRY(ANDROID_SCALER_CROP_REGION, mPixelArraySize.data(),
-                    mPixelArraySize.size());
+  res = base_metadata.update(ANDROID_SCALER_CROP_REGION, mPixelArraySize.data(),
+                             mPixelArraySize.size());
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.sensor. */
 
@@ -726,26 +993,43 @@
 
   // Ignored when AE is OFF.
   int64_t frame_duration = 33333333L; // 1/30 s.
-  ADD_REQUEST_ENTRY(ANDROID_SENSOR_FRAME_DURATION, &frame_duration, 1);
+  res = base_metadata.update(ANDROID_SENSOR_FRAME_DURATION, &frame_duration, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.shading. */
 
   uint8_t shading_mode = ANDROID_SHADING_MODE_FAST;
-  ADD_REQUEST_ENTRY(ANDROID_SHADING_MODE, &shading_mode, 1);
+  res = base_metadata.update(ANDROID_SHADING_MODE, &shading_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.statistics. */
 
   uint8_t face_detect_mode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_STATISTICS_FACE_DETECT_MODE, &face_detect_mode, 1);
+  res = base_metadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE,
+                             &face_detect_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   // histogramMode, sharpnessMapMode marked FUTURE.
 
   uint8_t hp_map_mode = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hp_map_mode, 1);
+  res = base_metadata.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
+                             &hp_map_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   uint8_t lens_shading_map_mode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
-  ADD_REQUEST_ENTRY(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
-                    &lens_shading_map_mode, 1);
+  res = base_metadata.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
+                             &lens_shading_map_mode, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.tonemap. */
 
@@ -754,7 +1038,10 @@
   /* android.led. */
 
   uint8_t transmit = ANDROID_LED_TRANSMIT_ON;
-  ADD_REQUEST_ENTRY(ANDROID_LED_TRANSMIT, &transmit, 1);
+  res = base_metadata.update(ANDROID_LED_TRANSMIT, &transmit, 1);
+  if (res != android::OK) {
+    return res;
+  }
 
   /* android.reprocess */
 
@@ -817,11 +1104,8 @@
   uint8_t video_af_mode =  continuous_video_avail ?
       ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO : non_continuous_af_mode;
 
-  // Copy our base metadata (note: we do it in this direction so we don't have
-  // to redefine our ADD_REQUEST_ENTRY macro).
-  android::CameraMetadata base_metadata(template_metadata);
-
-  for (uint8_t template_id = 1; template_id < CAMERA3_TEMPLATE_COUNT; ++template_id) {
+  for (uint8_t template_id = 1; template_id < CAMERA3_TEMPLATE_COUNT;
+       ++template_id) {
     // General differences/support.
     uint8_t intent;
     uint8_t af_mode;
@@ -854,10 +1138,21 @@
         continue;
     }
 
-    ADD_REQUEST_ENTRY(ANDROID_CONTROL_CAPTURE_INTENT, &intent, 1);
-    ADD_REQUEST_ENTRY(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-                      fps_range.data(), fps_range.size());
-    ADD_REQUEST_ENTRY(ANDROID_CONTROL_AF_MODE, &af_mode, 1);
+    // Copy our base metadata and add the new items.
+    android::CameraMetadata template_metadata(base_metadata);
+    res = template_metadata.update(ANDROID_CONTROL_CAPTURE_INTENT, &intent, 1);
+    if (res != android::OK) {
+      return res;
+    }
+    res = template_metadata.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
+                                   fps_range.data(), fps_range.size());
+    if (res != android::OK) {
+      return res;
+    }
+    res = template_metadata.update(ANDROID_CONTROL_AF_MODE, &af_mode, 1);
+    if (res != android::OK) {
+      return res;
+    }
 
     const camera_metadata_t* template_raw_metadata =
         template_metadata.getAndLock();
@@ -869,9 +1164,6 @@
     if (res != android::OK) {
       return res;
     }
-
-    // Reset the template metadata to the base.
-    template_metadata = base_metadata;
   }
 
   mTemplatesInitialized = true;