[RFC,v1,49/54] android: Update imported files

27133 diff mbox series

diff --git a/include/android/hardware/libhardware/include/hardware/camera3.h b/include/android/hardware/libhardware/include/hardware/camera3.h
index fd1e2072ad..fe7285f904 100644
--- a/include/android/hardware/libhardware/include/hardware/camera3.h
+++ b/include/android/hardware/libhardware/include/hardware/camera3.h
@@ -22,7 +22,7 @@ 
 #include "camera_common.h"
 
 /**
- * Camera device HAL 3.5[ CAMERA_DEVICE_API_VERSION_3_5 ]
+ * Camera device HAL 3.6[ CAMERA_DEVICE_API_VERSION_3_6 ]
  *
  * This is the current recommended version of the camera device HAL.
  *
@@ -30,7 +30,7 @@ 
  * android.hardware.camera2 API as LIMITED or above hardware level.
  *
  * Camera devices that support this version of the HAL must return
- * CAMERA_DEVICE_API_VERSION_3_5 in camera_device_t.common.version and in
+ * CAMERA_DEVICE_API_VERSION_3_6 in camera_device_t.common.version and in
  * camera_info_t.device_version (from camera_module_t.get_camera_info).
  *
  * CAMERA_DEVICE_API_VERSION_3_3 and above:
@@ -184,6 +184,25 @@ 
  *     for a logical multi camera, the application has the option to specify individual
  *     settings for a particular physical device.
  *
+ * 3.6: Minor revisions to support HAL buffer management APIs:
+ *
+ *   - Add ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION static metadata, which allows HAL to
+ *     opt in to the new buffer management APIs described below.
+ *
+ *   - Add request_stream_buffers() and return_stream_buffers() to camera3_callback_ops_t for HAL to
+ *     request and return output buffers from camera service.
+ *
+ *   - Add signal_stream_flush() to camera3_device_ops_t for camera service to notify HAL an
+ *     upcoming configure_streams() call requires HAL to return buffers of certain streams.
+ *
+ *   - Add CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID to support BLOB with only JPEG apps
+ *     segments and thumbnail (without main image bitstream). Camera framework
+ *     uses such stream togerther with a HAL YUV_420_888/IMPLEMENTATION_DEFINED
+ *     stream to encode HEIC (ISO/IEC 23008-12) image.
+ *
+ *   - Add is_reconfiguration_required() to camera3_device_ops_t to enable HAL to skip or
+ *     trigger stream reconfiguration depending on new session parameter values.
+ *
  */
 
 /**
@@ -1314,7 +1333,7 @@ 
  *      To avoid excessive amount of noise reduction and insufficient amount of edge enhancement
  *      being applied to the input buffer, the application can hint the HAL  how much effective
  *      exposure time improvement has been done by the application, then the HAL can adjust the
- *      noise reduction and edge enhancement paramters to get best reprocessed image quality.
+ *      noise reduction and edge enhancement parameters to get best reprocessed image quality.
  *      Below tag can be used for this purpose:
  *          - android.reprocess.effectiveExposureFactor
  *      The value would be exposure time increase factor applied to the original output image,
@@ -1737,24 +1756,8 @@  typedef struct camera3_stream {
      */
     const char* physical_camera_id;
 
-    /**
-     * This should be one of the camera3_stream_rotation_t values except for
-     * CAMERA3_STREAM_ROTATION_180.
-     * When setting to CAMERA3_STREAM_ROTATION_90 or CAMERA3_STREAM_ROTATION_270, HAL would crop,
-     * rotate the frame by the specified degrees clockwise and scale it up to original size.
-     * In Chrome OS, it's possible to have a portrait activity run in a landscape screen with
-     * landscape-mounted camera. The activity would show stretched or rotated preview because it
-     * does not expect to receive landscape preview frames. To solve this problem, we ask HAL to
-     * crop, rotate and scale the frames and modify CameraCharacteristics.SENSOR_ORIENTATION
-     * accordingly to imitate a portrait camera.
-     * Setting it to CAMERA3_STREAM_ROTATION_0 means no crop-rotate-scale would be performed.
-     * |cros_rotate_scale_degrees| in all camera3_stream_t of a configure_streams() call must be
-     * identical. The HAL should return -EINVAL if the degrees are not the same for all the streams.
-     */
-    int crop_rotate_scale_degrees;
-
     /* reserved for future use */
-    void *reserved[5];
+    void *reserved[6];
 
 } camera3_stream_t;
 
@@ -1958,21 +1961,25 @@  typedef struct camera3_stream_buffer_set {
 /**
  * camera3_jpeg_blob:
  *
- * Transport header for compressed JPEG buffers in output streams.
+ * Transport header for compressed JPEG or JPEG_APP_SEGMENTS buffers in output streams.
  *
- * To capture JPEG images, a stream is created using the pixel format
+ * To capture JPEG or JPEG_APP_SEGMENTS images, a stream is created using the pixel format
  * HAL_PIXEL_FORMAT_BLOB. The buffer size for the stream is calculated by the
- * framework, based on the static metadata field android.jpeg.maxSize. Since
- * compressed JPEG images are of variable size, the HAL needs to include the
- * final size of the compressed image using this structure inside the output
- * stream buffer. The JPEG blob ID field must be set to CAMERA3_JPEG_BLOB_ID.
+ * framework, based on the static metadata field android.jpeg.maxSize for JPEG,
+ * and android.jpeg.maxAppsSegments for JPEG_APP_SEGMENTS.
  *
- * Transport header should be at the end of the JPEG output stream buffer. That
+ * Since compressed JPEG/JPEG_APP_SEGMENTS images are of variable size, the HAL needs to
+ * include the final size of the image using this structure inside the output
+ * stream buffer. The JPEG blob ID field must be set to CAMERA3_JPEG_BLOB_ID for
+ * JPEG and CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID for APP segments.
+ *
+ * Transport header should be at the end of the output stream buffer. That
  * means the jpeg_blob_id must start at byte[buffer_size -
  * sizeof(camera3_jpeg_blob)], where the buffer_size is the size of gralloc buffer.
- * Any HAL using this transport header must account for it in android.jpeg.maxSize
- * The JPEG data itself starts at the beginning of the buffer and should be
- * jpeg_size bytes long.
+ * The blob data itself starts at the beginning of the buffer and should be
+ * jpeg_size bytes long. HAL using this transport header for JPEG must account for
+ * it in android.jpeg.maxSize. For JPEG APP segments, camera framework makes
+ * sure that the output stream buffer is large enough for the transport header.
  */
 typedef struct camera3_jpeg_blob {
     uint16_t jpeg_blob_id;
@@ -1980,7 +1987,8 @@  typedef struct camera3_jpeg_blob {
 } camera3_jpeg_blob_t;
 
 enum {
-    CAMERA3_JPEG_BLOB_ID = 0x00FF
+    CAMERA3_JPEG_BLOB_ID = 0x00FF,
+    CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID = 0x0100,
 };
 
 /**********************************************************************
@@ -2046,6 +2054,14 @@  typedef enum camera3_error_msg_code {
      * available. Subsequent requests are unaffected, and the device remains
      * operational.  The frame_number field specifies the request for which
      * result metadata won't be available.
+     *
+     * >= CAMERA_DEVICE_API_VERSION_3_6:
+     *
+     * In case the result metadata is absent for a logical camera device, then the
+     * error_stream pointer must be set to NULL.
+     * If the result metadata cannot be produced for a physical camera device, then
+     * error_stream must contain a pointer to a respective stream associated with
+     * that physical device.
      */
     CAMERA3_MSG_ERROR_RESULT = 3,
 
@@ -2143,6 +2159,153 @@  typedef struct camera3_notify_msg {
 
 } camera3_notify_msg_t;
 
+
+/**********************************************************************
+ *
+ * Types definition for request_stream_buffers() callback.
+ *
+ */
+
+/**
+ * camera3_buffer_request_status_t:
+ *
+ * The overall buffer request status returned by request_stream_buffers()
+ */
+typedef enum camera3_buffer_request_status {
+    /**
+     * request_stream_buffers() call succeeded and all requested buffers are
+     * returned.
+     */
+    CAMERA3_BUF_REQ_OK = 0,
+
+    /**
+     * request_stream_buffers() call failed for some streams.
+     * Check per stream status for each returned camera3_stream_buffer_ret_t.
+     */
+    CAMERA3_BUF_REQ_FAILED_PARTIAL = 1,
+
+    /**
+     * request_stream_buffers() call failed for all streams and no buffers are
+     * returned at all. Camera service is about to or is performing
+     * configure_streams() call. HAL must wait until next configure_streams()
+     * call is finished before requesting buffers again.
+     */
+    CAMERA3_BUF_REQ_FAILED_CONFIGURING = 2,
+
+    /**
+     * request_stream_buffers() call failed for all streams and no buffers are
+     * returned at all. Failure due to bad camera3_buffer_request input, eg:
+     * unknown stream or repeated stream in the list of buffer requests.
+     */
+    CAMERA3_BUF_REQ_FAILED_ILLEGAL_ARGUMENTS = 3,
+
+    /**
+     * request_stream_buffers() call failed for all streams and no buffers are
+     * returned at all. This can happen for unknown reasons or a combination
+     * of different failure reasons per stream. For the latter case, caller can
+     * check per stream failure reason returned in camera3_stream_buffer_ret.
+     */
+    CAMERA3_BUF_REQ_FAILED_UNKNOWN = 4,
+
+    /**
+     * Number of buffer request status
+     */
+    CAMERA3_BUF_REQ_NUM_STATUS
+
+} camera3_buffer_request_status_t;
+
+/**
+ * camera3_stream_buffer_req_status_t:
+ *
+ * The per stream buffer request status returned by request_stream_buffers()
+ */
+typedef enum camera3_stream_buffer_req_status {
+    /**
+     * Get buffer succeeds and all requested buffers are returned.
+     */
+    CAMERA3_PS_BUF_REQ_OK = 0,
+
+    /**
+     * Get buffer failed due to timeout waiting for an available buffer. This is
+     * likely due to the client application holding too many buffers, or the
+     * system is under memory pressure.
+     * This is not a fatal error. HAL can try to request buffer for this stream
+     * later. If HAL cannot get a buffer for certain capture request in time
+     * due to this error, HAL can send an ERROR_REQUEST to camera service and
+     * drop processing that request.
+     */
+    CAMERA3_PS_BUF_REQ_NO_BUFFER_AVAILABLE = 1,
+
+    /**
+     * Get buffer failed due to HAL has reached its maxBuffer count. This is not
+     * a fatal error. HAL can try to request buffer for this stream again after
+     * it returns at least one buffer of that stream to camera service.
+     */
+    CAMERA3_PS_BUF_REQ_MAX_BUFFER_EXCEEDED = 2,
+
+    /**
+     * Get buffer failed due to the stream is disconnected by client
+     * application, has been removed, or not recognized by camera service.
+     * This means application is no longer interested in this stream.
+     * Requesting buffer for this stream will never succeed after this error is
+     * returned. HAL must safely return all buffers of this stream after
+     * getting this error. If HAL gets another capture request later targeting
+     * a disconnected stream, HAL must send an ERROR_REQUEST to camera service
+     * and drop processing that request.
+     */
+    CAMERA3_PS_BUF_REQ_STREAM_DISCONNECTED = 3,
+
+    /**
+     * Get buffer failed for unknown reason. This is a fatal error and HAL must
+     * send ERROR_DEVICE to camera service and be ready to be closed.
+     */
+    CAMERA3_PS_BUF_REQ_UNKNOWN_ERROR = 4,
+
+    /**
+     * Number of buffer request status
+     */
+    CAMERA3_PS_BUF_REQ_NUM_STATUS
+} camera3_stream_buffer_req_status_t;
+
+typedef struct camera3_buffer_request {
+    /**
+     * The stream HAL wants to request buffer from
+     */
+    camera3_stream_t *stream;
+
+    /**
+     * The number of buffers HAL requested
+     */
+    uint32_t num_buffers_requested;
+} camera3_buffer_request_t;
+
+typedef struct camera3_stream_buffer_ret {
+    /**
+     * The stream HAL wants to request buffer from
+     */
+    camera3_stream_t *stream;
+
+    /**
+     * The status of buffer request of this stream
+     */
+    camera3_stream_buffer_req_status_t status;
+
+    /**
+     * Number of output buffers returned. Must be 0 when above status is not
+     * CAMERA3_PS_BUF_REQ_OK; otherwise the value must be equal to
+     * num_buffers_requested in the corresponding camera3_buffer_request_t
+     */
+    uint32_t num_output_buffers;
+
+    /**
+     * The returned output buffers for the stream.
+     * Caller of request_stream_buffers() should supply this with enough memory
+     * (num_buffers_requested * sizeof(camera3_stream_buffer_t))
+     */
+    camera3_stream_buffer_t *output_buffers;
+} camera3_stream_buffer_ret_t;
+
+
 /**********************************************************************
  *
  * Capture request/result definitions for the HAL process_capture_request()
@@ -2660,6 +2823,65 @@  typedef struct camera3_callback_ops {
     void (*notify)(const struct camera3_callback_ops *,
             const camera3_notify_msg_t *msg);
 
+    /**
+     * request_stream_buffers:
+     *
+     * <= CAMERA_DEVICE_API_VERISON_3_5:
+     *
+     *    DO NOT USE: not defined and must be NULL.
+     *
+     * >= CAMERA_DEVICE_API_VERISON_3_6:
+     *
+     * Synchronous callback for HAL to ask for output buffer from camera service.
+     *
+     * This call may be serialized in camera service so it is strongly
+     * recommended to only call this method from one thread.
+     *
+     * When camera device advertises
+     * (android.info.supportedBufferManagementVersion ==
+     * ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5), HAL
+     * can use this method to request buffers from camera service.
+     *
+     * Caller is responsible for allocating enough memory for returned_buf_reqs
+     * argument (num_buffer_reqs * sizeof(camera3_stream_buffer_ret_t)) bytes
+     * and also the memory for the output_buffers field in each
+     * camera3_stream_buffer_ret_t
+     * (num_buffers_requested * sizeof(camera3_stream_buffer_t)) bytes
+     *
+     * Performance requirements:
+     * This is a blocking call that takes more time with more buffers requested.
+     * HAL should not request large amount of buffers on a latency critical code
+     * path. It is highly recommended to use a dedicated thread to perform
+     * all requestStreamBuffer calls, and adjust the thread priority and/or
+     * timing of making the call in order for buffers to arrive before HAL is
+     * ready to fill the buffer.
+     */
+    camera3_buffer_request_status_t (*request_stream_buffers)(
+            const struct camera3_callback_ops *,
+            uint32_t num_buffer_reqs,
+            const camera3_buffer_request_t *buffer_reqs,
+            /*out*/uint32_t *num_returned_buf_reqs,
+            /*out*/camera3_stream_buffer_ret_t *returned_buf_reqs);
+
+    /**
+     * return_stream_buffers:
+     *
+     * <= CAMERA_DEVICE_API_VERISON_3_5:
+     *
+     *    DO NOT USE: not defined and must be NULL.
+     *
+     * >= CAMERA_DEVICE_API_VERISON_3_6:
+     *
+     * Synchronous callback for HAL to return output buffers to camera service.
+     *
+     * If this method is called during a configure_streams() call, it will be
+     * blocked until camera service finishes the ongoing configure_streams() call.
+     */
+    void (*return_stream_buffers)(
+            const struct camera3_callback_ops *,
+            uint32_t num_buffers,
+            const camera3_stream_buffer_t* const* buffers);
+
 } camera3_callback_ops_t;
 
 /**********************************************************************
@@ -3238,8 +3460,82 @@  typedef struct camera3_device_ops {
      */
     int (*flush)(const struct camera3_device *);
 
+    /**
+     * signal_stream_flush:
+     *
+     * <= CAMERA_DEVICE_API_VERISON_3_5:
+     *
+     *    Not defined and must be NULL
+     *
+     * >= CAMERA_DEVICE_API_VERISON_3_6:
+     *
+     * Signaling HAL camera service is about to perform configure_streams() call
+     * and HAL must return all buffers of designated streams. HAL must finish
+     * inflight requests normally and return all buffers belonging to the
+     * designated streams through process_capture_result() or
+     * return_stream_buffers() API in a timely manner, or camera service will run
+     * into a fatal error.
+     *
+     * Note that this call serves as an optional hint and camera service may
+     * skip calling this if all buffers are already returned.
+     *
+     */
+    void (*signal_stream_flush)(const struct camera3_device*,
+            uint32_t num_streams,
+            const camera3_stream_t* const* streams);
+
+    /**
+     * is_reconfiguration_required:
+     *
+     * <= CAMERA_DEVICE_API_VERISON_3_5:
+     *
+     *    Not defined and must be NULL
+     *
+     * >= CAMERA_DEVICE_API_VERISON_3_6:
+     *
+     * Check whether complete stream reconfiguration is required for possible new session
+     * parameter values.
+     *
+     * This method must be called by the camera framework in case the client changes
+     * the value of any advertised session parameters. Depending on the specific values
+     * the HAL can decide whether a complete stream reconfiguration is required. In case
+     * the HAL returns -ENVAL, the camera framework must skip the internal reconfiguration.
+     * In case Hal returns 0, the framework must reconfigure the streams and pass the
+     * new session parameter values accordingly.
+     * This call may be done by the framework some time before the request with new parameters
+     * is submitted to the HAL, and the request may be cancelled before it ever gets submitted.
+     * Therefore, the HAL must not use this query as an indication to change its behavior in any
+     * way.
+     * ------------------------------------------------------------------------
+     *
+     * Preconditions:
+     *
+     * The framework can call this method at any time after active
+     * session configuration. There must be no impact on the performance of
+     * pending camera requests in any way. In particular there must not be
+     * any glitches or delays during normal camera streaming.
+     *
+     * Performance requirements:
+     * HW and SW camera settings must not be changed and there must not be
+     * a user-visible impact on camera performance.
+     *
+     * @param oldSessionParams The currently applied session parameters.
+     * @param newSessionParams The new session parameters set by client.
+     *
+     * @return Status Status code for the operation, one of:
+     * 0:                    In case the stream reconfiguration is required
+     *
+     * -EINVAL:              In case the stream reconfiguration is not required.
+     *
+     * -ENOSYS:              In case the camera device does not support the
+     *                       reconfiguration query.
+     */
+    int (*is_reconfiguration_required)(const struct camera3_device*,
+            const camera_metadata_t* old_session_params,
+            const camera_metadata_t* new_session_params);
+
     /* reserved for future use */
-    void *reserved[8];
+    void *reserved[6];
 } camera3_device_ops_t;
 
 /**********************************************************************
diff --git a/include/android/hardware/libhardware/include/hardware/camera_common.h b/include/android/hardware/libhardware/include/hardware/camera_common.h
index 5c9bc06fe0..1d4a02a199 100644
--- a/include/android/hardware/libhardware/include/hardware/camera_common.h
+++ b/include/android/hardware/libhardware/include/hardware/camera_common.h
@@ -118,6 +118,22 @@  __BEGIN_DECLS
  * 4. Module initialization method. This will be called by the camera service
  *    right after the HAL module is loaded, to allow for one-time initialization
  *    of the HAL. It is called before any other module methods are invoked.
+ *
+ *******************************************************************************
+ * Version: 2.5 [CAMERA_MODULE_API_VERSION_2_5]
+ *
+ * This camera module version adds below API changes:
+ *
+ * 1. Support to query characteristics of a non-standalone physical camera, which can
+ *    only be accessed as part of a logical camera. It also adds camera stream combination
+ *    query.
+ *
+ * 2. Ability to query whether a particular camera stream combination is
+ *    supported by the camera device.
+ *
+ * 3. Device state change notification. This module version also supports
+ *    notification about the overall device state change, such as
+ *    folding/unfolding, or covering/uncovering of shutter.
  */
 
 /**
@@ -134,8 +150,9 @@  __BEGIN_DECLS
 #define CAMERA_MODULE_API_VERSION_2_2 HARDWARE_MODULE_API_VERSION(2, 2)
 #define CAMERA_MODULE_API_VERSION_2_3 HARDWARE_MODULE_API_VERSION(2, 3)
 #define CAMERA_MODULE_API_VERSION_2_4 HARDWARE_MODULE_API_VERSION(2, 4)
+#define CAMERA_MODULE_API_VERSION_2_5 HARDWARE_MODULE_API_VERSION(2, 5)
 
-#define CAMERA_MODULE_API_VERSION_CURRENT CAMERA_MODULE_API_VERSION_2_4
+#define CAMERA_MODULE_API_VERSION_CURRENT CAMERA_MODULE_API_VERSION_2_5
 
 /**
  * All device versions <= HARDWARE_DEVICE_API_VERSION(1, 0xFF) must be treated
@@ -150,6 +167,7 @@  __BEGIN_DECLS
 #define CAMERA_DEVICE_API_VERSION_3_3 HARDWARE_DEVICE_API_VERSION(3, 3)
 #define CAMERA_DEVICE_API_VERSION_3_4 HARDWARE_DEVICE_API_VERSION(3, 4)
 #define CAMERA_DEVICE_API_VERSION_3_5 HARDWARE_DEVICE_API_VERSION(3, 5)
+#define CAMERA_DEVICE_API_VERSION_3_6 HARDWARE_DEVICE_API_VERSION(3, 6)
 
 // Device version 3.5 is current, older HAL camera device versions are not
 // recommended for new devices.
@@ -645,6 +663,192 @@  typedef struct camera_module_callbacks {
 
 } camera_module_callbacks_t;
 
+/**
+ * camera_stream_t:
+ *
+ * A handle to a single camera input or output stream. A stream is defined by
+ * the framework by its buffer resolution and format and gralloc usage flags.
+ *
+ * The stream structures are owned by the framework and pointers to a
+ * camera_stream passed into the HAL by is_stream_combination_supported() are
+ * only valid within the scope of the call.
+ *
+ * All camera_stream members are immutable.
+ */
+typedef struct camera_stream {
+    /**
+     * The type of the stream, one of the camera3_stream_type_t values.
+     */
+    int stream_type;
+
+    /**
+     * The width in pixels of the buffers in this stream
+     */
+    uint32_t width;
+
+    /**
+     * The height in pixels of the buffers in this stream
+     */
+    uint32_t height;
+
+    /**
+     * The pixel format for the buffers in this stream. Format is a value from
+     * the HAL_PIXEL_FORMAT_* list in system/core/include/system/graphics.h, or
+     * from device-specific headers.
+     *
+     * If HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED is used, then the platform
+     * gralloc module will select a format based on the usage flags provided by
+     * the camera device and the other endpoint of the stream.
+     *
+     */
+    int format;
+
+    /**
+     * The gralloc usage flags for this stream, as needed by the HAL. The usage
+     * flags are defined in gralloc.h (GRALLOC_USAGE_*), or in device-specific
+     * headers.
+     *
+     * For output streams, these are the HAL's producer usage flags. For input
+     * streams, these are the HAL's consumer usage flags. The usage flags from
+     * the producer and the consumer will be combined together and then passed
+     * to the platform gralloc HAL module for allocating the gralloc buffers for
+     * each stream.
+     *
+     * The usage flag for an output stream may be bitwise
+     * combination of usage flags for multiple consumers, for the purpose of
+     * sharing one camera stream between those consumers. The HAL must fail
+     * the stream combination query call with -EINVAL if the combined flags cannot be
+     * supported due to imcompatible buffer format, dataSpace, or other hardware
+     * limitations.
+     */
+    uint32_t usage;
+
+    /**
+     * A field that describes the contents of the buffer. The format and buffer
+     * dimensions define the memory layout and structure of the stream buffers,
+     * while dataSpace defines the meaning of the data within the buffer.
+     *
+     * For most formats, dataSpace defines the color space of the image data.
+     * In addition, for some formats, dataSpace indicates whether image- or
+     * depth-based data is requested.  See system/core/include/system/graphics.h
+     * for details of formats and valid dataSpace values for each format.
+     *
+     * Always set by the camera service. The dataspace values are set
+     * using the V0 dataspace definitions in graphics.h
+     */
+    android_dataspace_t data_space;
+
+    /**
+     * The required output rotation of the stream, one of
+     * the camera3_stream_rotation_t values. This must be inspected by HAL along
+     * with stream width and height. For example, if the rotation is 90 degree
+     * and the stream width and height is 720 and 1280 respectively, camera service
+     * will supply buffers of size 720x1280, and HAL should capture a 1280x720 image
+     * and rotate the image by 90 degree counterclockwise. The rotation field is
+     * no-op when the stream type is input. Camera HAL must ignore the rotation
+     * field for an input stream.
+     *
+     * Always set by camera service. HAL must inspect this field during stream
+     * combination query and return -EINVAL if it cannot perform such rotation.
+     * HAL must always support CAMERA3_STREAM_ROTATION_0, so a
+     * is_stream_combination_supported() call must not fail for unsupported rotation if
+     * rotation field of all streams is CAMERA3_STREAM_ROTATION_0.
+     *
+     */
+    int rotation;
+
+    /**
+     * The physical camera id this stream belongs to.
+     * Always set by camera service. If the camera device is not a logical
+     * multi camera, or if the camera is a logical multi camera but the stream
+     * is not a physical output stream, this field will point to a 0-length
+     * string.
+     *
+     * A logical multi camera is a camera device backed by multiple physical
+     * cameras that are also exposed to the application. And for a logical
+     * multi camera, a physical output stream is an output stream specifically
+     * requested on an underlying physical camera.
+     *
+     * For an input stream, this field is guaranteed to be a 0-length string.
+     */
+    const char* physical_camera_id;
+
+} camera_stream_t;
+
+/**
+ * camera_stream_combination_t:
+ *
+ * A structure of stream definitions, used by is_stream_combination_supported(). This
+ * structure defines all the input & output streams for specific camera use case.
+ */
+typedef struct camera_stream_combination {
+    /**
+     * The total number of streams by the framework.  This includes
+     * both input and output streams. The number of streams will be at least 1,
+     * and there will be at least one output-capable stream.
+     */
+    uint32_t num_streams;
+
+    /**
+     * An array of camera streams, defining the input/output
+     * stream combination for the camera HAL device.
+     *
+     * At most one input-capable stream may be defined.
+     *
+     * At least one output-capable stream must be defined.
+     */
+    camera_stream_t *streams;
+
+    /**
+     * The operation mode of streams in this stream combination, one of the value
+     * defined in camera3_stream_configuration_mode_t.
+     *
+     */
+    uint32_t operation_mode;
+
+} camera_stream_combination_t;
+
+/**
+ * device_state_t:
+ *
+ * Possible physical states of the overall device, for use with
+ * notify_device_state_change.
+ */
+typedef enum device_state {
+    /**
+     * The device is in its normal physical configuration. This is the default if the
+     * device does not support multiple different states.
+     */
+    NORMAL = 0,
+
+    /**
+     * Camera device(s) facing backward are covered.
+     */
+    BACK_COVERED = 1 << 0,
+
+    /**
+     * Camera device(s) facing foward are covered.
+     */
+    FRONT_COVERED = 1 << 1,
+
+    /**
+     * The device is folded.  If not set, the device is unfolded or does not
+     * support folding.
+     *
+     * The exact point when this status change happens during the folding
+     * operation is device-specific.
+     */
+    FOLDED = 1 << 2,
+
+    /**
+     * First vendor-specific device state. All bits above and including this one
+     * are for vendor state values.  Values below this one must only be used
+     * for framework-defined states.
+     */
+    VENDOR_STATE_START = 1LL << 32
+
+} device_state_t;
+
 typedef struct camera_module {
     /**
      * Common methods of the camera module.  This *must* be the first member of
@@ -910,8 +1114,104 @@  typedef struct camera_module {
      */
     int (*init)();
 
+    /**
+     * get_physical_camera_info:
+     *
+     * Return the static metadata for a physical camera as a part of a logical
+     * camera device. This function is only called for those physical camera
+     * ID(s) that are not exposed independently. In other words, camera_id will
+     * be greater or equal to the return value of get_number_of_cameras().
+     *
+     * Return values:
+     *
+     * 0:           On a successful operation
+     *
+     * -ENODEV:     The information cannot be provided due to an internal
+     *              error.
+     *
+     * -EINVAL:     The input arguments are invalid, i.e. the id is invalid,
+     *              and/or the module is invalid.
+     *
+     * Version information (based on camera_module_t.common.module_api_version):
+     *
+     * CAMERA_MODULE_API_VERSION_1_x/2_0/2_1/2_2/2_3/2_4:
+     *   Not provided by HAL module. Framework will not call this function.
+     *
+     * CAMERA_MODULE_API_VERSION_2_5 or higher:
+     *   If any of the camera devices accessible through this camera module is
+     *   a logical multi-camera, and at least one of the physical cameras isn't
+     *   a stand-alone camera device, this function will be called by the camera
+     *   framework. Calling this function with invalid physical_camera_id will
+     *   get -EINVAL, and NULL static_metadata.
+     */
+    int (*get_physical_camera_info)(int physical_camera_id,
+            camera_metadata_t **static_metadata);
+
+    /**
+     * is_stream_combination_supported:
+     *
+     * Check for device support of specific camera stream combination.
+     *
+     * Return values:
+     *
+     * 0:           In case the stream combination is supported.
+     *
+     * -EINVAL:     In case the stream combination is not supported.
+     *
+     * -ENOSYS:     In case stream combination query is not supported.
+     *
+     * Version information (based on camera_module_t.common.module_api_version):
+     *
+     * CAMERA_MODULE_API_VERSION_1_x/2_0/2_1/2_2/2_3/2_4:
+     *   Not provided by HAL module. Framework will not call this function.
+     *
+     * CAMERA_MODULE_API_VERSION_2_5 or higher:
+     *   Valid to be called by the framework.
+     */
+    int (*is_stream_combination_supported)(int camera_id,
+            const camera_stream_combination_t *streams);
+
+    /**
+     * notify_device_state_change:
+     *
+     * Notify the camera module that the state of the overall device has
+     * changed in some way that the HAL may want to know about.
+     *
+     * For example, a physical shutter may have been uncovered or covered,
+     * or a camera may have been covered or uncovered by an add-on keyboard
+     * or other accessory.
+     *
+     * The state is a bitfield of potential states, and some physical configurations
+     * could plausibly correspond to multiple different combinations of state bits.
+     * The HAL must ignore any state bits it is not actively using to determine
+     * the appropriate camera configuration.
+     *
+     * For example, on some devices the FOLDED state could mean that
+     * backward-facing cameras are covered by the fold, so FOLDED by itself implies
+     * BACK_COVERED. But other devices may support folding but not cover any cameras
+     * when folded, so for those FOLDED would not imply any of the other flags.
+     * Since these relationships are very device-specific, it is difficult to specify
+     * a comprehensive policy.  But as a recommendation, it is suggested that if a flag
+     * necessarily implies other flags are set as well, then those flags should be set.
+     * So even though FOLDED would be enough to infer BACK_COVERED on some devices, the
+     * BACK_COVERED flag should also be set for clarity.
+     *
+     * This method may be invoked by the HAL client at any time. It must not
+     * cause any active camera device sessions to be closed, but may dynamically
+     * change which physical camera a logical multi-camera is using for its
+     * active and future output.
+     *
+     * The method must be invoked by the HAL client at least once before the
+     * client calls ICameraDevice::open on any camera device interfaces listed
+     * by this provider, to establish the initial device state.
+     *
+     * Note that the deviceState is 64-bit bitmask, with system defined states in
+     * lower 32-bit and vendor defined states in upper 32-bit.
+     */
+    void (*notify_device_state_change)(uint64_t deviceState);
+
     /* reserved for future use */
-    void* reserved[5];
+    void* reserved[2];
 } camera_module_t;
 
 __END_DECLS
diff --git a/include/android/hardware/libhardware/include/hardware/gralloc.h b/include/android/hardware/libhardware/include/hardware/gralloc.h
index 01a7672747..2c5514b8ec 100644
--- a/include/android/hardware/libhardware/include/hardware/gralloc.h
+++ b/include/android/hardware/libhardware/include/hardware/gralloc.h
@@ -19,8 +19,8 @@ 
 #ifndef ANDROID_GRALLOC_INTERFACE_H
 #define ANDROID_GRALLOC_INTERFACE_H
 
-#include <hardware/hardware.h>
 #include <system/graphics.h>
+#include <hardware/hardware.h>
 
 #include <stdint.h>
 #include <sys/cdefs.h>
@@ -28,8 +28,8 @@ 
 
 #include <cutils/native_handle.h>
 
-#include <hardware/fb.h>
 #include <hardware/hardware.h>
+#include <hardware/fb.h>
 
 __BEGIN_DECLS
 
@@ -132,6 +132,9 @@  enum {
      * handle this flag. */
     GRALLOC_USAGE_FOREIGN_BUFFERS       = 0x00200000U,
 
+    /* buffer will be used as input to HW HEIC image encoder */
+    GRALLOC_USAGE_HW_IMAGE_ENCODER      = 0x08000000U,
+
     /* Mask of all flags which could be passed to a gralloc module for buffer
      * allocation. Any flags not in this mask do not need to be handled by
      * gralloc modules. */
@@ -154,20 +157,20 @@  enum {
  */
 typedef struct gralloc_module_t {
     struct hw_module_t common;
-    
+
     /*
      * (*registerBuffer)() must be called before a buffer_handle_t that has not
      * been created with (*alloc_device_t::alloc)() can be used.
-     * 
+     *
      * This is intended to be used with buffer_handle_t's that have been
      * received in this process through IPC.
-     * 
+     *
      * This function checks that the handle is indeed a valid one and prepares
      * it for use with (*lock)() and (*unlock)().
-     * 
-     * It is not necessary to call (*registerBuffer)() on a handle created 
+     *
+     * It is not necessary to call (*registerBuffer)() on a handle created
      * with (*alloc_device_t::alloc)().
-     * 
+     *
      * returns an error if this buffer_handle_t is not valid.
      */
     int (*registerBuffer)(struct gralloc_module_t const* module,
@@ -177,25 +180,25 @@  typedef struct gralloc_module_t {
      * (*unregisterBuffer)() is called once this handle is no longer needed in
      * this process. After this call, it is an error to call (*lock)(),
      * (*unlock)(), or (*registerBuffer)().
-     * 
+     *
      * This function doesn't close or free the handle itself; this is done
      * by other means, usually through libcutils's native_handle_close() and
-     * native_handle_free(). 
-     * 
+     * native_handle_free().
+     *
      * It is an error to call (*unregisterBuffer)() on a buffer that wasn't
      * explicitly registered first.
      */
     int (*unregisterBuffer)(struct gralloc_module_t const* module,
             buffer_handle_t handle);
-    
+
     /*
-     * The (*lock)() method is called before a buffer is accessed for the 
+     * The (*lock)() method is called before a buffer is accessed for the
      * specified usage. This call may block, for instance if the h/w needs
      * to finish rendering or if CPU caches need to be synchronized.
-     * 
-     * The caller promises to modify only pixels in the area specified 
+     *
+     * The caller promises to modify only pixels in the area specified
      * by (l,t,w,h).
-     * 
+     *
      * The content of the buffer outside of the specified area is NOT modified
      * by this call.
      *
@@ -208,9 +211,9 @@  typedef struct gralloc_module_t {
      *
      * THREADING CONSIDERATIONS:
      *
-     * It is legal for several different threads to lock a buffer from 
+     * It is legal for several different threads to lock a buffer from
      * read access, none of the threads are blocked.
-     * 
+     *
      * However, locking a buffer simultaneously for write or read/write is
      * undefined, but:
      * - shall not result in termination of the process
@@ -219,21 +222,21 @@  typedef struct gralloc_module_t {
      * into an indeterminate state.
      *
      * If the buffer was created with a usage mask incompatible with the
-     * requested usage flags here, -EINVAL is returned. 
-     * 
+     * requested usage flags here, -EINVAL is returned.
+     *
      */
-    
+
     int (*lock)(struct gralloc_module_t const* module,
             buffer_handle_t handle, int usage,
             int l, int t, int w, int h,
             void** vaddr);
 
-    
+
     /*
      * The (*unlock)() method must be called after all changes to the buffer
      * are completed.
      */
-    
+
     int (*unlock)(struct gralloc_module_t const* module,
             buffer_handle_t handle);
 
@@ -312,8 +315,38 @@  typedef struct gralloc_module_t {
             int l, int t, int w, int h,
             struct android_ycbcr *ycbcr, int fenceFd);
 
+    /* getTransportSize(..., outNumFds, outNumInts)
+     * This function is mandatory on devices running IMapper2.1 or higher.
+     *
+     * Get the transport size of a buffer. An imported buffer handle is a raw
+     * buffer handle with the process-local runtime data appended. This
+     * function, for example, allows a caller to omit the process-local
+     * runtime data at the tail when serializing the imported buffer handle.
+     *
+     * Note that a client might or might not omit the process-local runtime
+     * data when sending an imported buffer handle. The mapper must support
+     * both cases on the receiving end.
+     */
+    int32_t (*getTransportSize)(
+            struct gralloc_module_t const* module, buffer_handle_t handle, uint32_t *outNumFds,
+            uint32_t *outNumInts);
+
+    /* validateBufferSize(..., w, h, format, usage, stride)
+     * This function is mandatory on devices running IMapper2.1 or higher.
+     *
+     * Validate that the buffer can be safely accessed by a caller who assumes
+     * the specified width, height, format, usage, and stride. This must at least validate
+     * that the buffer size is large enough. Validating the buffer against
+     * individual buffer attributes is optional.
+     */
+    int32_t (*validateBufferSize)(
+            struct gralloc_module_t const* device, buffer_handle_t handle,
+            uint32_t w, uint32_t h, int32_t format, int usage,
+            uint32_t stride);
+
     /* reserved for future use */
-    void* reserved_proc[3];
+    void* reserved_proc[1];
+
 } gralloc_module_t;
 
 /*****************************************************************************/
@@ -326,32 +359,32 @@  typedef struct gralloc_module_t {
 typedef struct alloc_device_t {
     struct hw_device_t common;
 
-    /* 
+    /*
      * (*alloc)() Allocates a buffer in graphic memory with the requested
      * parameters and returns a buffer_handle_t and the stride in pixels to
      * allow the implementation to satisfy hardware constraints on the width
-     * of a pixmap (eg: it may have to be multiple of 8 pixels). 
+     * of a pixmap (eg: it may have to be multiple of 8 pixels).
      * The CALLER TAKES OWNERSHIP of the buffer_handle_t.
      *
      * If format is HAL_PIXEL_FORMAT_YCbCr_420_888, the returned stride must be
      * 0, since the actual strides are available from the android_ycbcr
      * structure.
-     * 
+     *
      * Returns 0 on success or -errno on error.
      */
-    
+
     int (*alloc)(struct alloc_device_t* dev,
             int w, int h, int format, int usage,
             buffer_handle_t* handle, int* stride);
 
     /*
-     * (*free)() Frees a previously allocated buffer. 
+     * (*free)() Frees a previously allocated buffer.
      * Behavior is undefined if the buffer is still mapped in any process,
      * but shall not result in termination of the program or security breaches
      * (allowing a process to get access to another process' buffers).
      * THIS FUNCTION TAKES OWNERSHIP of the buffer_handle_t which becomes
-     * invalid after the call. 
-     * 
+     * invalid after the call.
+     *
      * Returns 0 on success or -errno on error.
      */
     int (*free)(struct alloc_device_t* dev,
@@ -369,9 +402,9 @@  typedef struct alloc_device_t {
 
 /** convenience API for opening and closing a supported device */
 
-static inline int gralloc_open(const struct hw_module_t* module, 
+static inline int gralloc_open(const struct hw_module_t* module,
         struct alloc_device_t** device) {
-    return module->methods->open(module, 
+    return module->methods->open(module,
             GRALLOC_HARDWARE_GPU0, TO_HW_DEVICE_T_OPEN(device));
 }
 
diff --git a/include/android/metadata/camera_metadata_hidden.h b/include/android/metadata/camera_metadata_hidden.h
index 91b11e4346..5629f7981b 100644
--- a/include/android/metadata/camera_metadata_hidden.h
+++ b/include/android/metadata/camera_metadata_hidden.h
@@ -18,6 +18,9 @@ 
 #ifndef SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H
 #define SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H
 
+#include <stdint.h>
+#include <cutils/compiler.h>
+#include <system/camera_metadata.h>
 #include <system/camera_vendor_tags.h>
 
 /**
@@ -35,14 +38,6 @@  extern "C" {
 #endif
 /** **These are private functions for use only by the camera framework.** **/
 
-/**
- * Set the global vendor tag operations object used to define vendor tag
- * structure when parsing camera metadata with functions defined in
- * system/media/camera/include/camera_metadata.h.
- */
-ANDROID_API
-int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops);
-
 /**
  * Set the global vendor tag cache operations object used to define vendor tag
  * structure when parsing camera metadata with functions defined in
diff --git a/include/android/metadata/system/camera_metadata.h b/include/android/metadata/system/camera_metadata.h
index 1672b09ee9..44c836144f 100644
--- a/include/android/metadata/system/camera_metadata.h
+++ b/include/android/metadata/system/camera_metadata.h
@@ -18,13 +18,13 @@ 
 #ifndef SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_METADATA_H
 #define SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_METADATA_H
 
+#include <sys/cdefs.h>
 #include <string.h>
 #include <stdint.h>
 #include <cutils/compiler.h>
+#include <system/camera_vendor_tags.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+__BEGIN_DECLS
 
 /**
  * Tag hierarchy and enum definitions for camera_metadata_entry
@@ -287,7 +287,7 @@  enum {
 };
 
 /**
- * Validate that a metadata is structurally sane. That is, its internal
+ * Validate that a metadata is structurally correct. That is, its internal
  * state is such that we won't get buffer overflows or run into other
  * 'impossible' issues when calling the other API functions.
  *
@@ -481,6 +481,12 @@  ANDROID_API
 int get_local_camera_metadata_tag_type(uint32_t tag,
         const camera_metadata_t *meta);
 
+/**
+ * Retrieve all tags that need permission.
+ */
+ANDROID_API
+const int32_t *get_camera_metadata_permission_needed(uint32_t *tag_count);
+
 /**
  * Set up vendor-specific tag query methods. These are needed to properly add
  * entries with vendor-specified tags and to use the
@@ -574,8 +580,29 @@  int camera_metadata_enum_snprint(uint32_t tag,
                                  char *dst,
                                  size_t size);
 
-#ifdef __cplusplus
-}
-#endif
+/**
+ * Retrieves back the binary value of a given tag enum entry name. Only works for enum tags.
+ * Returns 0 on success, -1 on failure.
+ */
+ANDROID_API
+int camera_metadata_enum_value(uint32_t tag /*in*/,
+                               const char* name /*in*/,
+                               size_t size /*in*/,
+                               uint32_t *value /*out*/);
+
+/**
+ * Set the global vendor tag operations object used to define vendor tag
+ * structure when parsing camera metadata with functions defined in
+ * system/media/camera/include/camera_metadata.h.
+ *
+ * Note: this is moved from system/media/private/camera/include/camera_metadata_hidden.h.
+ * Every process that needs to read or write vendor tags has to call this method before
+ * attempting to use them. The OS will handle standard app and system service processes,
+ * but OEMs may need to invoke this method in HALs that process camera data.
+ */
+ANDROID_API
+int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops);
+
+__END_DECLS
 
 #endif
diff --git a/include/android/metadata/system/camera_metadata_tags.h b/include/android/metadata/system/camera_metadata_tags.h
index e0f2f5a37a..af6d5258ae 100644
--- a/include/android/metadata/system/camera_metadata_tags.h
+++ b/include/android/metadata/system/camera_metadata_tags.h
@@ -64,6 +64,14 @@  typedef enum camera_metadata_section {
     ANDROID_DEPTH,
     ANDROID_LOGICAL_MULTI_CAMERA,
     ANDROID_DISTORTION_CORRECTION,
+    ANDROID_HEIC,
+    ANDROID_HEIC_INFO,
+    ANDROID_AUTOMOTIVE,
+    ANDROID_AUTOMOTIVE_LENS,
+    ANDROID_EXTENSION,
+    ANDROID_JPEGR,
+    ANDROID_SHARED_SESSION,
+    ANDROID_DESKTOP_EFFECTS,
     ANDROID_SECTION_COUNT,
 
     VENDOR_SECTION = 0x8000
@@ -106,6 +114,14 @@  typedef enum camera_metadata_section_start {
     ANDROID_DISTORTION_CORRECTION_START
                                    = ANDROID_DISTORTION_CORRECTION
                                                                 << 16,
+    ANDROID_HEIC_START             = ANDROID_HEIC              << 16,
+    ANDROID_HEIC_INFO_START        = ANDROID_HEIC_INFO         << 16,
+    ANDROID_AUTOMOTIVE_START       = ANDROID_AUTOMOTIVE        << 16,
+    ANDROID_AUTOMOTIVE_LENS_START  = ANDROID_AUTOMOTIVE_LENS   << 16,
+    ANDROID_EXTENSION_START        = ANDROID_EXTENSION         << 16,
+    ANDROID_JPEGR_START            = ANDROID_JPEGR             << 16,
+    ANDROID_SHARED_SESSION_START   = ANDROID_SHARED_SESSION    << 16,
+    ANDROID_DESKTOP_EFFECTS_START  = ANDROID_DESKTOP_EFFECTS   << 16,
     VENDOR_SECTION_START           = VENDOR_SECTION            << 16
 } camera_metadata_section_start_t;
 
@@ -123,6 +139,10 @@  typedef enum camera_metadata_tag {
     ANDROID_COLOR_CORRECTION_ABERRATION_MODE,         // enum         | public       | HIDL v3.2
     ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
                                                       // byte[]       | public       | HIDL v3.2
+    ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE,       // int32        | public       | HIDL v3.11
+    ANDROID_COLOR_CORRECTION_COLOR_TINT,              // int32        | public       | HIDL v3.11
+    ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE, // int32[]      | public       | HIDL v3.11
+    ANDROID_COLOR_CORRECTION_AVAILABLE_MODES,         // byte[]       | public       | HIDL v3.11
     ANDROID_COLOR_CORRECTION_END,
 
     ANDROID_CONTROL_AE_ANTIBANDING_MODE =             // enum         | public       | HIDL v3.2
@@ -171,6 +191,30 @@  typedef enum camera_metadata_tag {
     ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,       // int32        | public       | HIDL v3.2
     ANDROID_CONTROL_ENABLE_ZSL,                       // enum         | public       | HIDL v3.2
     ANDROID_CONTROL_AF_SCENE_CHANGE,                  // enum         | public       | HIDL v3.3
+    ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES,
+                                                      // int32[]      | ndk_public   | HIDL v3.5
+    ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES,
+                                                      // float[]      | ndk_public   | HIDL v3.5
+    ANDROID_CONTROL_EXTENDED_SCENE_MODE,              // enum         | public       | HIDL v3.5
+    ANDROID_CONTROL_ZOOM_RATIO_RANGE,                 // float[]      | public       | HIDL v3.5
+    ANDROID_CONTROL_ZOOM_RATIO,                       // float        | public       | HIDL v3.5
+    ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int32[]      | hidden       | HIDL v3.6
+    ANDROID_CONTROL_AF_REGIONS_SET,                   // enum         | fwk_only
+    ANDROID_CONTROL_AE_REGIONS_SET,                   // enum         | fwk_only
+    ANDROID_CONTROL_AWB_REGIONS_SET,                  // enum         | fwk_only
+    ANDROID_CONTROL_SETTINGS_OVERRIDE,                // enum         | public       | HIDL v3.9
+    ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES,     // int32[]      | public       | HIDL v3.9
+    ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER, // int32        | system       | HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING,                      // enum         | public       | HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_AVAILABLE,            // enum         | public       | HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_STATE,                // enum         | public       | HIDL v3.9
+    ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE,
+                                                      // float[]      | public       | HIDL v3.10
+    ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE,            // enum         | public       | HIDL v3.10
+    ANDROID_CONTROL_ZOOM_METHOD,                      // enum         | fwk_public
+    ANDROID_CONTROL_AE_PRIORITY_MODE,                 // enum         | public       | HIDL v3.11
+    ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES,      // byte[]       | public       | HIDL v3.11
     ANDROID_CONTROL_END,
 
     ANDROID_DEMOSAIC_MODE =                           // enum         | system       | HIDL v3.2
@@ -190,11 +234,18 @@  typedef enum camera_metadata_tag {
     ANDROID_FLASH_COLOR_TEMPERATURE,                  // byte         | system       | HIDL v3.2
     ANDROID_FLASH_MAX_ENERGY,                         // byte         | system       | HIDL v3.2
     ANDROID_FLASH_STATE,                              // enum         | public       | HIDL v3.2
+    ANDROID_FLASH_STRENGTH_LEVEL,                     // int32        | public       | HIDL v3.10
+    ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL,          // int32        | public       | HIDL v3.10
+    ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL,      // int32        | public       | HIDL v3.10
+    ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL,           // int32        | public       | HIDL v3.10
+    ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL,       // int32        | public       | HIDL v3.10
     ANDROID_FLASH_END,
 
     ANDROID_FLASH_INFO_AVAILABLE =                    // enum         | public       | HIDL v3.2
             ANDROID_FLASH_INFO_START,
     ANDROID_FLASH_INFO_CHARGE_DURATION,               // int64        | system       | HIDL v3.2
+    ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL,        // int32        | public       | HIDL v3.8
+    ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL,        // int32        | public       | HIDL v3.8
     ANDROID_FLASH_INFO_END,
 
     ANDROID_HOT_PIXEL_MODE =                          // enum         | public       | HIDL v3.2
@@ -230,6 +281,9 @@  typedef enum camera_metadata_tag {
     ANDROID_LENS_RADIAL_DISTORTION,                   // float[]      | public       | HIDL v3.2
     ANDROID_LENS_POSE_REFERENCE,                      // enum         | public       | HIDL v3.3
     ANDROID_LENS_DISTORTION,                          // float[]      | public       | HIDL v3.3
+    ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION,       // float[]      | public       | HIDL v3.6
+    ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION,
+                                                      // float[]      | public       | HIDL v3.6
     ANDROID_LENS_END,
 
     ANDROID_LENS_INFO_AVAILABLE_APERTURES =           // float[]      | public       | HIDL v3.2
@@ -277,7 +331,15 @@  typedef enum camera_metadata_tag {
     ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,   // int32[]      | ndk_public   | HIDL v3.2
     ANDROID_REQUEST_AVAILABLE_SESSION_KEYS,           // int32[]      | ndk_public   | HIDL v3.3
     ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS,
-                                                      // int32[]      | hidden       | HIDL v3.3
+                                                      // int32[]      | ndk_public   | HIDL v3.3
+    ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,
+                                                      // int32[]      | hidden       | HIDL v3.4
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP,
+                                                      // enum[]       | ndk_public   | HIDL v3.8
+    ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE,
+                                                      // int64        | java_public  | HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP,
+                                                      // enum[]       | ndk_public   | HIDL v3.9
     ANDROID_REQUEST_END,
 
     ANDROID_SCALER_CROP_REGION =                      // int32[]      | public       | HIDL v3.2
@@ -295,6 +357,29 @@  typedef enum camera_metadata_tag {
     ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,     // int64[]      | ndk_public   | HIDL v3.2
     ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,         // int64[]      | ndk_public   | HIDL v3.2
     ANDROID_SCALER_CROPPING_TYPE,                     // enum         | public       | HIDL v3.2
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS,
+                                                      // enum[]       | ndk_public   | HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP,
+                                                      // int32        | ndk_public   | HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,   // byte[]       | public       | HIDL v3.5
+    ANDROID_SCALER_ROTATE_AND_CROP,                   // enum         | public       | HIDL v3.5
+    ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE,         // int32[]      | public       | HIDL v3.6
+    ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS,
+                                                      // enum[]       | ndk_public   | HIDL v3.6
+    ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.6
+    ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION,
+                                                      // int32        | hidden       | HIDL v3.6
+    ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED, // enum         | ndk_public   | HIDL v3.6
+    ANDROID_SCALER_CROP_REGION_SET,                   // enum         | fwk_only
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES,        // enum[]       | public       | HIDL v3.8
+    ANDROID_SCALER_RAW_CROP_REGION,                   // int32[]      | public       | HIDL v3.9
+    ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS,
+                                                      // int32[]      | ndk_public   | HIDL v3.12
     ANDROID_SCALER_END,
 
     ANDROID_SENSOR_EXPOSURE_TIME =                    // int64        | public       | HIDL v3.2
@@ -329,6 +414,10 @@  typedef enum camera_metadata_tag {
     ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL,               // float[]      | public       | HIDL v3.2
     ANDROID_SENSOR_DYNAMIC_WHITE_LEVEL,               // int32        | public       | HIDL v3.2
     ANDROID_SENSOR_OPAQUE_RAW_SIZE,                   // int32[]      | system       | HIDL v3.2
+    ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION,// int32[]      | system       | HIDL v3.6
+    ANDROID_SENSOR_PIXEL_MODE,                        // enum         | public       | HIDL v3.6
+    ANDROID_SENSOR_RAW_BINNING_FACTOR_USED,           // enum         | public       | HIDL v3.6
+    ANDROID_SENSOR_READOUT_TIMESTAMP,                 // enum         | java_public  | HIDL v3.8
     ANDROID_SENSOR_END,
 
     ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE =           // int32[]      | public       | HIDL v3.2
@@ -344,6 +433,13 @@  typedef enum camera_metadata_tag {
     ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED,         // enum         | public       | HIDL v3.2
     ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
                                                       // int32[]      | public       | HIDL v3.2
+    ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION,
+                                                      // int32[]      | public       | HIDL v3.6
+    ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION,
+                                                      // int32[]      | public       | HIDL v3.6
+    ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION,
+                                                      // int32[]      | public       | HIDL v3.6
+    ANDROID_SENSOR_INFO_BINNING_FACTOR,               // int32[]      | public       | HIDL v3.6
     ANDROID_SENSOR_INFO_END,
 
     ANDROID_SHADING_MODE =                            // enum         | public       | HIDL v3.2
@@ -374,9 +470,11 @@  typedef enum camera_metadata_tag {
     ANDROID_STATISTICS_OIS_TIMESTAMPS,                // int64[]      | ndk_public   | HIDL v3.3
     ANDROID_STATISTICS_OIS_X_SHIFTS,                  // float[]      | ndk_public   | HIDL v3.3
     ANDROID_STATISTICS_OIS_Y_SHIFTS,                  // float[]      | ndk_public   | HIDL v3.3
+    ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS,     // int64[]      | ndk_public   | HIDL v3.10
+    ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES,        // float[]      | ndk_public   | HIDL v3.10
     ANDROID_STATISTICS_END,
 
-    ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES = 
+    ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES =
                                                       // byte[]       | public       | HIDL v3.2
             ANDROID_STATISTICS_INFO_START,
     ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,   // int32        | system       | HIDL v3.2
@@ -410,6 +508,11 @@  typedef enum camera_metadata_tag {
     ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL =           // enum         | public       | HIDL v3.2
             ANDROID_INFO_START,
     ANDROID_INFO_VERSION,                             // byte         | public       | HIDL v3.3
+    ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, // enum         | system       | HIDL v3.4
+    ANDROID_INFO_DEVICE_STATE_ORIENTATIONS,           // int64[]      | ndk_public   | HIDL v3.7
+    ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION, // enum         | fwk_java_public
+    ANDROID_INFO_DEVICE_ID,                           // int32        | fwk_only
+    ANDROID_INFO_DEVICE_TYPE,                         // enum         | public       | HIDL v3.12
     ANDROID_INFO_END,
 
     ANDROID_BLACK_LEVEL_LOCK =                        // enum         | public       | HIDL v3.2
@@ -433,11 +536,35 @@  typedef enum camera_metadata_tag {
     ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,// int64[]      | ndk_public   | HIDL v3.2
     ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,    // int64[]      | ndk_public   | HIDL v3.2
     ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE,                 // enum         | public       | HIDL v3.2
+    ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS,
+                                                      // int32[]      | ndk_public   | HIDL v3.4
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
+                                                      // enum[]       | ndk_public   | HIDL v3.4
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
+                                                      // int64[]      | ndk_public   | HIDL v3.4
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
+                                                      // int64[]      | ndk_public   | HIDL v3.4
+    ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
     ANDROID_DEPTH_END,
 
-    ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS =       // byte[]       | hidden       | HIDL v3.3
+    ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS =       // byte[]       | ndk_public   | HIDL v3.3
             ANDROID_LOGICAL_MULTI_CAMERA_START,
     ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE,    // enum         | public       | HIDL v3.3
+    ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID,  // byte         | public       | HIDL v3.4
+    ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION,
+                                                      // int32[]      | public       | HIDL v3.10
+    ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS,  // enum         | public       | HIDL v3.12
     ANDROID_LOGICAL_MULTI_CAMERA_END,
 
     ANDROID_DISTORTION_CORRECTION_MODE =              // enum         | public       | HIDL v3.3
@@ -445,6 +572,78 @@  typedef enum camera_metadata_tag {
     ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES,    // byte[]       | public       | HIDL v3.3
     ANDROID_DISTORTION_CORRECTION_END,
 
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS =
+                                                      // enum[]       | ndk_public   | HIDL v3.4
+            ANDROID_HEIC_START,
+    ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS,  // int64[]      | ndk_public   | HIDL v3.4
+    ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS,      // int64[]      | ndk_public   | HIDL v3.4
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.6
+    ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.6
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS,
+                                                      // enum[]       | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS,
+                                                      // int64[]      | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS,
+                                                      // int64[]      | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.11
+    ANDROID_HEIC_END,
+
+    ANDROID_HEIC_INFO_SUPPORTED =                     // enum         | system       | HIDL v3.4
+            ANDROID_HEIC_INFO_START,
+    ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT,    // byte         | system       | HIDL v3.4
+    ANDROID_HEIC_INFO_END,
+
+    ANDROID_AUTOMOTIVE_LOCATION =                     // enum         | public       | HIDL v3.8
+            ANDROID_AUTOMOTIVE_START,
+    ANDROID_AUTOMOTIVE_END,
+
+    ANDROID_AUTOMOTIVE_LENS_FACING =                  // enum[]       | public       | HIDL v3.8
+            ANDROID_AUTOMOTIVE_LENS_START,
+    ANDROID_AUTOMOTIVE_LENS_END,
+
+    ANDROID_EXTENSION_STRENGTH =                      // int32        | extension_passthrough | HIDL v3.9
+            ANDROID_EXTENSION_START,
+    ANDROID_EXTENSION_CURRENT_TYPE,                   // int32        | fwk_java_public
+    ANDROID_EXTENSION_NIGHT_MODE_INDICATOR,           // enum         | public       | HIDL v3.11
+    ANDROID_EXTENSION_END,
+
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS =
+                                                      // enum[]       | ndk_public   | HIDL v3.9
+            ANDROID_JPEGR_START,
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS,
+                                                      // int64[]      | ndk_public   | HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS,   // int64[]      | ndk_public   | HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,
+                                                      // enum[]       | ndk_public   | HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION,
+                                                      // int64[]      | ndk_public   | HIDL v3.9
+    ANDROID_JPEGR_END,
+
+    ANDROID_SHARED_SESSION_COLOR_SPACE =              // enum         | fwk_only
+            ANDROID_SHARED_SESSION_START,
+    ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS,     // int64[]      | fwk_only
+    ANDROID_SHARED_SESSION_END,
+
+    ANDROID_DESKTOP_EFFECTS_CAPABILITIES =            // enum[]       | system       | HIDL v3.2
+            ANDROID_DESKTOP_EFFECTS_START,
+    ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES,    // byte[]       | system       | HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE,     // enum         | system       | HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE,        // enum         | system       | HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH,    // byte         | system       | HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE,    // enum         | system       | HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_END,
+
 } camera_metadata_tag_t;
 
 /**
@@ -456,6 +655,7 @@  typedef enum camera_metadata_enum_android_color_correction_mode {
     ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX                  , // HIDL v3.2
     ANDROID_COLOR_CORRECTION_MODE_FAST                              , // HIDL v3.2
     ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY                      , // HIDL v3.2
+    ANDROID_COLOR_CORRECTION_MODE_CCT                               , // HIDL v3.11
 } camera_metadata_enum_android_color_correction_mode_t;
 
 // ANDROID_COLOR_CORRECTION_ABERRATION_MODE
@@ -488,6 +688,7 @@  typedef enum camera_metadata_enum_android_control_ae_mode {
     ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH                         , // HIDL v3.2
     ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE                    , // HIDL v3.2
     ANDROID_CONTROL_AE_MODE_ON_EXTERNAL_FLASH                       , // HIDL v3.3
+    ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY  , // HIDL v3.10
 } camera_metadata_enum_android_control_ae_mode_t;
 
 // ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER
@@ -564,6 +765,7 @@  typedef enum camera_metadata_enum_android_control_mode {
     ANDROID_CONTROL_MODE_AUTO                                       , // HIDL v3.2
     ANDROID_CONTROL_MODE_USE_SCENE_MODE                             , // HIDL v3.2
     ANDROID_CONTROL_MODE_OFF_KEEP_STATE                             , // HIDL v3.2
+    ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE                    , // HIDL v3.5
 } camera_metadata_enum_android_control_mode_t;
 
 // ANDROID_CONTROL_SCENE_MODE
@@ -596,6 +798,7 @@  typedef enum camera_metadata_enum_android_control_scene_mode {
 typedef enum camera_metadata_enum_android_control_video_stabilization_mode {
     ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF                    , // HIDL v3.2
     ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON                     , // HIDL v3.2
+    ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION  , // HIDL v3.8
 } camera_metadata_enum_android_control_video_stabilization_mode_t;
 
 // ANDROID_CONTROL_AE_STATE
@@ -651,6 +854,78 @@  typedef enum camera_metadata_enum_android_control_af_scene_change {
     ANDROID_CONTROL_AF_SCENE_CHANGE_DETECTED                        , // HIDL v3.3
 } camera_metadata_enum_android_control_af_scene_change_t;
 
+// ANDROID_CONTROL_EXTENDED_SCENE_MODE
+typedef enum camera_metadata_enum_android_control_extended_scene_mode {
+    ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED                     = 0, // HIDL v3.5
+    ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE         , // HIDL v3.5
+    ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS            , // HIDL v3.5
+    ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START                 = 0x40, // HIDL v3.5
+} camera_metadata_enum_android_control_extended_scene_mode_t;
+
+// ANDROID_CONTROL_AF_REGIONS_SET
+typedef enum camera_metadata_enum_android_control_af_regions_set {
+    ANDROID_CONTROL_AF_REGIONS_SET_FALSE                            ,
+    ANDROID_CONTROL_AF_REGIONS_SET_TRUE                             ,
+} camera_metadata_enum_android_control_af_regions_set_t;
+
+// ANDROID_CONTROL_AE_REGIONS_SET
+typedef enum camera_metadata_enum_android_control_ae_regions_set {
+    ANDROID_CONTROL_AE_REGIONS_SET_FALSE                            ,
+    ANDROID_CONTROL_AE_REGIONS_SET_TRUE                             ,
+} camera_metadata_enum_android_control_ae_regions_set_t;
+
+// ANDROID_CONTROL_AWB_REGIONS_SET
+typedef enum camera_metadata_enum_android_control_awb_regions_set {
+    ANDROID_CONTROL_AWB_REGIONS_SET_FALSE                           ,
+    ANDROID_CONTROL_AWB_REGIONS_SET_TRUE                            ,
+} camera_metadata_enum_android_control_awb_regions_set_t;
+
+// ANDROID_CONTROL_SETTINGS_OVERRIDE
+typedef enum camera_metadata_enum_android_control_settings_override {
+    ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF                           , // HIDL v3.9
+    ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM                          , // HIDL v3.9
+    ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START                   = 0x4000, // HIDL v3.9
+} camera_metadata_enum_android_control_settings_override_t;
+
+// ANDROID_CONTROL_AUTOFRAMING
+typedef enum camera_metadata_enum_android_control_autoframing {
+    ANDROID_CONTROL_AUTOFRAMING_OFF                                 , // HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_ON                                  , // HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_AUTO                                , // HIDL v3.9
+} camera_metadata_enum_android_control_autoframing_t;
+
+// ANDROID_CONTROL_AUTOFRAMING_AVAILABLE
+typedef enum camera_metadata_enum_android_control_autoframing_available {
+    ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE                     , // HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE                      , // HIDL v3.9
+} camera_metadata_enum_android_control_autoframing_available_t;
+
+// ANDROID_CONTROL_AUTOFRAMING_STATE
+typedef enum camera_metadata_enum_android_control_autoframing_state {
+    ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE                      , // HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING                       , // HIDL v3.9
+    ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED                     , // HIDL v3.9
+} camera_metadata_enum_android_control_autoframing_state_t;
+
+// ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE
+typedef enum camera_metadata_enum_android_control_low_light_boost_state {
+    ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE                  , // HIDL v3.10
+    ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE                    , // HIDL v3.10
+} camera_metadata_enum_android_control_low_light_boost_state_t;
+
+// ANDROID_CONTROL_ZOOM_METHOD
+typedef enum camera_metadata_enum_android_control_zoom_method {
+    ANDROID_CONTROL_ZOOM_METHOD_AUTO                                 = 0,
+    ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO                           = 1,
+} camera_metadata_enum_android_control_zoom_method_t;
+
+// ANDROID_CONTROL_AE_PRIORITY_MODE
+typedef enum camera_metadata_enum_android_control_ae_priority_mode {
+    ANDROID_CONTROL_AE_PRIORITY_MODE_OFF                            , // HIDL v3.11
+    ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY    , // HIDL v3.11
+    ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY  , // HIDL v3.11
+} camera_metadata_enum_android_control_ae_priority_mode_t;
+
 
 // ANDROID_DEMOSAIC_MODE
 typedef enum camera_metadata_enum_android_demosaic_mode {
@@ -724,6 +999,8 @@  typedef enum camera_metadata_enum_android_lens_state {
 typedef enum camera_metadata_enum_android_lens_pose_reference {
     ANDROID_LENS_POSE_REFERENCE_PRIMARY_CAMERA                      , // HIDL v3.3
     ANDROID_LENS_POSE_REFERENCE_GYROSCOPE                           , // HIDL v3.3
+    ANDROID_LENS_POSE_REFERENCE_UNDEFINED                           , // HIDL v3.5
+    ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE                          , // HIDL v3.8
 } camera_metadata_enum_android_lens_pose_reference_t;
 
 
@@ -780,8 +1057,75 @@  typedef enum camera_metadata_enum_android_request_available_capabilities {
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING          , // HIDL v3.3
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA     , // HIDL v3.3
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME               , // HIDL v3.3
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA        , // HIDL v3.4
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA            , // HIDL v3.5
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING       , // HIDL v3.5
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR
+                                                                     , // HIDL v3.6
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING    , // HIDL v3.6
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT    , // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE          , // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES     , // HIDL v3.9
 } camera_metadata_enum_android_request_available_capabilities_t;
 
+// ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP
+typedef enum camera_metadata_enum_android_request_available_dynamic_range_profiles_map {
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD    = 0x1, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10       = 0x2, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10       = 0x4, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS  = 0x8, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF
+                                                                      = 0x10, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO
+                                                                      = 0x20, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM
+                                                                      = 0x40, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO
+                                                                      = 0x80, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF
+                                                                      = 0x100, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO
+                                                                      = 0x200, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM
+                                                                      = 0x400, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO
+                                                                      = 0x800, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX         = 0x1000, // HIDL v3.8
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50
+                                                                      = 0x2000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50
+                                                                      = 0x4000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50
+                                                                      = 0x8000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50
+                                                                      = 0x10000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50
+                                                                      = 0x20000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50
+                                                                      = 0x40000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50
+                                                                      = 0x80000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50
+                                                                      = 0x100000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50
+                                                                      = 0x200000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50
+                                                                      = 0x400000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50
+                                                                      = 0x800000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50
+                                                                      = 0x1000000, // HIDL v3.12
+    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312     = 0x2000000, // HIDL v3.12
+} camera_metadata_enum_android_request_available_dynamic_range_profiles_map_t;
+
+// ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP
+typedef enum camera_metadata_enum_android_request_available_color_space_profiles_map {
+    ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED   = -1, // HIDL v3.9
+    ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB          = 0, // HIDL v3.9
+    ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3    = 7, // HIDL v3.9
+    ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG    = 16, // HIDL v3.9
+} camera_metadata_enum_android_request_available_color_space_profiles_map_t;
+
 
 // ANDROID_SCALER_AVAILABLE_FORMATS
 typedef enum camera_metadata_enum_android_scaler_available_formats {
@@ -792,6 +1136,10 @@  typedef enum camera_metadata_enum_android_scaler_available_formats {
     ANDROID_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED          = 0x22, // HIDL v3.2
     ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888                   = 0x23, // HIDL v3.2
     ANDROID_SCALER_AVAILABLE_FORMATS_BLOB                            = 0x21, // HIDL v3.2
+    ANDROID_SCALER_AVAILABLE_FORMATS_RAW10                           = 0x25, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_FORMATS_RAW12                           = 0x26, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_FORMATS_RAW14                           = 0x2C, // HIDL v3.12
+    ANDROID_SCALER_AVAILABLE_FORMATS_Y8                              = 0x20203859, // HIDL v3.4
 } camera_metadata_enum_android_scaler_available_formats_t;
 
 // ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
@@ -806,6 +1154,79 @@  typedef enum camera_metadata_enum_android_scaler_cropping_type {
     ANDROID_SCALER_CROPPING_TYPE_FREEFORM                           , // HIDL v3.2
 } camera_metadata_enum_android_scaler_cropping_type_t;
 
+// ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_scaler_available_recommended_stream_configurations {
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW
+                                                                      = 0x0, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD
+                                                                      = 0x1, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT
+                                                                      = 0x2, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT
+                                                                      = 0x3, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL   = 0x4, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW   = 0x5, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT
+                                                                      = 0x6, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END
+                                                                      = 0x7, // HIDL v3.4
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT
+                                                                      = 0x8, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8
+                                                                      = 0x9, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START
+                                                                      = 0x18, // HIDL v3.4
+} camera_metadata_enum_android_scaler_available_recommended_stream_configurations_t;
+
+// ANDROID_SCALER_ROTATE_AND_CROP
+typedef enum camera_metadata_enum_android_scaler_rotate_and_crop {
+    ANDROID_SCALER_ROTATE_AND_CROP_NONE                             , // HIDL v3.5
+    ANDROID_SCALER_ROTATE_AND_CROP_90                               , // HIDL v3.5
+    ANDROID_SCALER_ROTATE_AND_CROP_180                              , // HIDL v3.5
+    ANDROID_SCALER_ROTATE_AND_CROP_270                              , // HIDL v3.5
+    ANDROID_SCALER_ROTATE_AND_CROP_AUTO                             , // HIDL v3.5
+} camera_metadata_enum_android_scaler_rotate_and_crop_t;
+
+// ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_scaler_physical_camera_multi_resolution_stream_configurations {
+    ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT
+                                                                     , // HIDL v3.6
+    ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT
+                                                                     , // HIDL v3.6
+} camera_metadata_enum_android_scaler_physical_camera_multi_resolution_stream_configurations_t;
+
+// ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_scaler_available_stream_configurations_maximum_resolution {
+    ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.6
+    ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.6
+} camera_metadata_enum_android_scaler_available_stream_configurations_maximum_resolution_t;
+
+// ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED
+typedef enum camera_metadata_enum_android_scaler_multi_resolution_stream_supported {
+    ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE          , // HIDL v3.6
+    ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE           , // HIDL v3.6
+} camera_metadata_enum_android_scaler_multi_resolution_stream_supported_t;
+
+// ANDROID_SCALER_CROP_REGION_SET
+typedef enum camera_metadata_enum_android_scaler_crop_region_set {
+    ANDROID_SCALER_CROP_REGION_SET_FALSE                            ,
+    ANDROID_SCALER_CROP_REGION_SET_TRUE                             ,
+} camera_metadata_enum_android_scaler_crop_region_set_t;
+
+// ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES
+typedef enum camera_metadata_enum_android_scaler_available_stream_use_cases {
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT                = 0x0, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW                = 0x1, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE          = 0x2, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD           = 0x3, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL    = 0x4, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL             = 0x5, // HIDL v3.8
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW            = 0x6, // HIDL v3.9
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START           = 0x10000, // HIDL v3.8
+} camera_metadata_enum_android_scaler_available_stream_use_cases_t;
+
 
 // ANDROID_SENSOR_REFERENCE_ILLUMINANT1
 typedef enum camera_metadata_enum_android_sensor_reference_illuminant1 {
@@ -837,9 +1258,28 @@  typedef enum camera_metadata_enum_android_sensor_test_pattern_mode {
     ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS                     , // HIDL v3.2
     ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY        , // HIDL v3.2
     ANDROID_SENSOR_TEST_PATTERN_MODE_PN9                            , // HIDL v3.2
+    ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK                          , // HIDL v3.6
     ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1                         = 256, // HIDL v3.2
 } camera_metadata_enum_android_sensor_test_pattern_mode_t;
 
+// ANDROID_SENSOR_PIXEL_MODE
+typedef enum camera_metadata_enum_android_sensor_pixel_mode {
+    ANDROID_SENSOR_PIXEL_MODE_DEFAULT                               , // HIDL v3.6
+    ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION                    , // HIDL v3.6
+} camera_metadata_enum_android_sensor_pixel_mode_t;
+
+// ANDROID_SENSOR_RAW_BINNING_FACTOR_USED
+typedef enum camera_metadata_enum_android_sensor_raw_binning_factor_used {
+    ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE                     , // HIDL v3.6
+    ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE                    , // HIDL v3.6
+} camera_metadata_enum_android_sensor_raw_binning_factor_used_t;
+
+// ANDROID_SENSOR_READOUT_TIMESTAMP
+typedef enum camera_metadata_enum_android_sensor_readout_timestamp {
+    ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED                  , // HIDL v3.8
+    ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE                       , // HIDL v3.8
+} camera_metadata_enum_android_sensor_readout_timestamp_t;
+
 
 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
 typedef enum camera_metadata_enum_android_sensor_info_color_filter_arrangement {
@@ -848,6 +1288,8 @@  typedef enum camera_metadata_enum_android_sensor_info_color_filter_arrangement {
     ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG               , // HIDL v3.2
     ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR               , // HIDL v3.2
     ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB                , // HIDL v3.2
+    ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO               , // HIDL v3.4
+    ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR                , // HIDL v3.4
 } camera_metadata_enum_android_sensor_info_color_filter_arrangement_t;
 
 // ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE
@@ -954,6 +1396,30 @@  typedef enum camera_metadata_enum_android_info_supported_hardware_level {
     ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL                  , // HIDL v3.3
 } camera_metadata_enum_android_info_supported_hardware_level_t;
 
+// ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION
+typedef enum camera_metadata_enum_android_info_supported_buffer_management_version {
+    ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5, // HIDL v3.4
+    ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE
+                                                                     , // HIDL v3.10
+} camera_metadata_enum_android_info_supported_buffer_management_version_t;
+
+// ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION
+typedef enum camera_metadata_enum_android_info_session_configuration_query_version {
+    ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE
+                                                                      = 34,
+    ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM
+                                                                      = 35,
+    ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA         = 36,
+} camera_metadata_enum_android_info_session_configuration_query_version_t;
+
+// ANDROID_INFO_DEVICE_TYPE
+typedef enum camera_metadata_enum_android_info_device_type {
+    ANDROID_INFO_DEVICE_TYPE_BUILT_IN                               , // HIDL v3.12
+    ANDROID_INFO_DEVICE_TYPE_EXTERNAL                               , // HIDL v3.12
+    ANDROID_INFO_DEVICE_TYPE_VIRTUAL                                , // HIDL v3.12
+    ANDROID_INFO_DEVICE_TYPE_UNKNOWN                                , // HIDL v3.12
+} camera_metadata_enum_android_info_device_type_t;
+
 
 // ANDROID_BLACK_LEVEL_LOCK
 typedef enum camera_metadata_enum_android_black_level_lock {
@@ -988,6 +1454,30 @@  typedef enum camera_metadata_enum_android_depth_depth_is_exclusive {
     ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE                           , // HIDL v3.2
 } camera_metadata_enum_android_depth_depth_is_exclusive_t;
 
+// ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations {
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT
+                                                                     , // HIDL v3.4
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT
+                                                                     , // HIDL v3.4
+} camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_t;
+
+// ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_depth_available_depth_stream_configurations_maximum_resolution {
+    ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.6
+} camera_metadata_enum_android_depth_available_depth_stream_configurations_maximum_resolution_t;
+
+// ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_maximum_resolution {
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.6
+    ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.6
+} camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_maximum_resolution_t;
+
 
 // ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE
 typedef enum camera_metadata_enum_android_logical_multi_camera_sensor_sync_type {
@@ -995,6 +1485,12 @@  typedef enum camera_metadata_enum_android_logical_multi_camera_sensor_sync_type
     ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED        , // HIDL v3.3
 } camera_metadata_enum_android_logical_multi_camera_sensor_sync_type_t;
 
+// ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS
+typedef enum camera_metadata_enum_android_logical_multi_camera_additional_results {
+    ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF             , // HIDL v3.12
+    ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON              , // HIDL v3.12
+} camera_metadata_enum_android_logical_multi_camera_additional_results_t;
+
 
 // ANDROID_DISTORTION_CORRECTION_MODE
 typedef enum camera_metadata_enum_android_distortion_correction_mode {
@@ -1004,3 +1500,134 @@  typedef enum camera_metadata_enum_android_distortion_correction_mode {
 } camera_metadata_enum_android_distortion_correction_mode_t;
 
 
+// ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_heic_available_heic_stream_configurations {
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT        , // HIDL v3.4
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT         , // HIDL v3.4
+} camera_metadata_enum_android_heic_available_heic_stream_configurations_t;
+
+// ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_heic_available_heic_stream_configurations_maximum_resolution {
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.6
+    ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.6
+} camera_metadata_enum_android_heic_available_heic_stream_configurations_maximum_resolution_t;
+
+// ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations {
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT
+                                                                     , // HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT
+                                                                     , // HIDL v3.11
+} camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_t;
+
+// ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_maximum_resolution {
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.11
+    ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.11
+} camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_maximum_resolution_t;
+
+
+// ANDROID_HEIC_INFO_SUPPORTED
+typedef enum camera_metadata_enum_android_heic_info_supported {
+    ANDROID_HEIC_INFO_SUPPORTED_FALSE                               , // HIDL v3.4
+    ANDROID_HEIC_INFO_SUPPORTED_TRUE                                , // HIDL v3.4
+} camera_metadata_enum_android_heic_info_supported_t;
+
+
+// ANDROID_AUTOMOTIVE_LOCATION
+typedef enum camera_metadata_enum_android_automotive_location {
+    ANDROID_AUTOMOTIVE_LOCATION_INTERIOR                            , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER                      , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT                      , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR                       , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT                       , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT                      , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER                         , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT                         , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR                          , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT                          , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT                         , // HIDL v3.8
+} camera_metadata_enum_android_automotive_location_t;
+
+
+// ANDROID_AUTOMOTIVE_LENS_FACING
+typedef enum camera_metadata_enum_android_automotive_lens_facing {
+    ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER                   , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT                   , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR                    , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT                    , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT                   , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER                   , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT         , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER       , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT        , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT         , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER       , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT        , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT         , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER       , // HIDL v3.8
+    ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT        , // HIDL v3.8
+} camera_metadata_enum_android_automotive_lens_facing_t;
+
+
+// ANDROID_EXTENSION_NIGHT_MODE_INDICATOR
+typedef enum camera_metadata_enum_android_extension_night_mode_indicator {
+    ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN                  , // HIDL v3.11
+    ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF                      , // HIDL v3.11
+    ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON                       , // HIDL v3.11
+} camera_metadata_enum_android_extension_night_mode_indicator_t;
+
+
+// ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS
+typedef enum camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations {
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT     , // HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT      , // HIDL v3.9
+} camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_t;
+
+// ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION
+typedef enum camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_maximum_resolution {
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT
+                                                                     , // HIDL v3.9
+    ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT
+                                                                     , // HIDL v3.9
+} camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_maximum_resolution_t;
+
+
+// ANDROID_SHARED_SESSION_COLOR_SPACE
+typedef enum camera_metadata_enum_android_shared_session_color_space {
+    ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED                   = -1,
+    ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB                          = 0,
+    ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3                    = 7,
+    ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG                    = 16,
+} camera_metadata_enum_android_shared_session_color_space_t;
+
+
+// ANDROID_DESKTOP_EFFECTS_CAPABILITIES
+typedef enum camera_metadata_enum_android_desktop_effects_capabilities {
+    ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR            , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH               , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT           , // HIDL v3.2
+} camera_metadata_enum_android_desktop_effects_capabilities_t;
+
+// ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE
+typedef enum camera_metadata_enum_android_desktop_effects_background_blur_mode {
+    ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF                , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT              , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL               , // HIDL v3.2
+} camera_metadata_enum_android_desktop_effects_background_blur_mode_t;
+
+// ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE
+typedef enum camera_metadata_enum_android_desktop_effects_face_retouch_mode {
+    ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF                   , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON                    , // HIDL v3.2
+} camera_metadata_enum_android_desktop_effects_face_retouch_mode_t;
+
+// ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE
+typedef enum camera_metadata_enum_android_desktop_effects_portrait_relight_mode {
+    ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF               , // HIDL v3.2
+    ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON                , // HIDL v3.2
+} camera_metadata_enum_android_desktop_effects_portrait_relight_mode_t;
diff --git a/include/android/metadata/system/camera_vendor_tags.h b/include/android/metadata/system/camera_vendor_tags.h
index 167ff7393a..52d0e9bbc0 100644
--- a/include/android/metadata/system/camera_vendor_tags.h
+++ b/include/android/metadata/system/camera_vendor_tags.h
@@ -18,9 +18,9 @@ 
 #ifndef SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H
 #define SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
 
 #define CAMERA_METADATA_VENDOR_TAG_BOUNDARY 0x80000000u
 #define CAMERA_METADATA_INVALID_VENDOR_ID UINT64_MAX
@@ -151,9 +151,7 @@  struct vendor_tag_cache_ops {
     void* reserved[8];
 };
 
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
+__END_DECLS
 
 #endif /* SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H */
 
diff --git a/include/android/system/core/include/android/log.h b/include/android/system/core/include/android/log.h
index dbad9dd18a..b5d725c7db 100644
--- a/include/android/system/core/include/android/log.h
+++ b/include/android/system/core/include/android/log.h
@@ -15,29 +15,18 @@ 
  * limitations under the License.
  */
 
-#ifndef _ANDROID_LOG_H
-#define _ANDROID_LOG_H
+#pragma once
 
-/******************************************************************
- *
- * IMPORTANT NOTICE:
- *
- *   This file is part of Android's set of stable system headers
- *   exposed by the Android NDK (Native Development Kit) since
- *   platform release 1.5
- *
- *   Third-party source AND binary code relies on the definitions
- *   here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES.
- *
- *   - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES)
- *   - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS
- *   - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY
- *   - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES
+/**
+ * @addtogroup Logging
+ * @{
  */
 
-/*
- * Support routines to send messages to the Android in-kernel log buffer,
- * which can later be accessed through the 'logcat' utility.
+/**
+ * \file
+ *
+ * Support routines to send messages to the Android log buffer,
+ * which can later be accessed through the `logcat` utility.
  *
  * Each log message must have
  *   - a priority
@@ -48,98 +37,393 @@ 
  * and should be reasonably small.
  *
  * Log message text may be truncated to less than an implementation-specific
- * limit (e.g. 1023 characters max).
+ * limit (1023 bytes).
  *
  * Note that a newline character ("\n") will be appended automatically to your
- * log message, if not already there. It is not possible to send several messages
- * and have them appear on a single line in logcat.
+ * log message, if not already there. It is not possible to send several
+ * messages and have them appear on a single line in logcat.
  *
- * PLEASE USE LOGS WITH MODERATION:
+ * Please use logging in moderation:
  *
  *  - Sending log messages eats CPU and slow down your application and the
  *    system.
  *
- *  - The circular log buffer is pretty small (<64KB), sending many messages
- *    might push off other important log messages from the rest of the system.
+ *  - The circular log buffer is pretty small, so sending many messages
+ *    will hide other important log messages.
  *
  *  - In release builds, only send log messages to account for exceptional
  *    conditions.
- *
- * NOTE: These functions MUST be implemented by /system/lib/liblog.so
  */
 
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/time.h>
+
+#if !defined(__BIONIC__) && !defined(__INTRODUCED_IN)
+#define __INTRODUCED_IN(x)
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*
- * Android log priority values, in ascending priority order.
+/**
+ * Android log priority values, in increasing order of priority.
  */
 typedef enum android_LogPriority {
-    ANDROID_LOG_UNKNOWN = 0,
-    ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */
-    ANDROID_LOG_VERBOSE,
-    ANDROID_LOG_DEBUG,
-    ANDROID_LOG_INFO,
-    ANDROID_LOG_WARN,
-    ANDROID_LOG_ERROR,
-    ANDROID_LOG_FATAL,
-    ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */
+  /** For internal use only.  */
+  ANDROID_LOG_UNKNOWN = 0,
+  /** The default priority, for internal use only.  */
+  ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */
+  /** Verbose logging. Should typically be disabled for a release apk. */
+  ANDROID_LOG_VERBOSE,
+  /** Debug logging. Should typically be disabled for a release apk. */
+  ANDROID_LOG_DEBUG,
+  /** Informational logging. Should typically be disabled for a release apk. */
+  ANDROID_LOG_INFO,
+  /** Warning logging. For use with recoverable failures. */
+  ANDROID_LOG_WARN,
+  /** Error logging. For use with unrecoverable failures. */
+  ANDROID_LOG_ERROR,
+  /** Fatal logging. For use when aborting. */
+  ANDROID_LOG_FATAL,
+  /** For internal use only.  */
+  ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */
 } android_LogPriority;
 
-/*
- * Send a simple string to the log.
+/**
+ * Identifies a specific log buffer for __android_log_buf_write()
+ * and __android_log_buf_print().
  */
-int __android_log_write(int prio, const char *tag, const char *text);
+typedef enum log_id {
+  /** For internal use only.  */
+  LOG_ID_MIN = 0,
 
-/*
- * Send a formatted string to the log, used like printf(fmt,...)
- */
-int __android_log_print(int prio, const char *tag,  const char *fmt, ...)
-#if defined(__GNUC__)
-#ifdef __USE_MINGW_ANSI_STDIO
-#if __USE_MINGW_ANSI_STDIO
-    __attribute__ ((format(gnu_printf, 3, 4)))
-#else
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-#else
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-#endif
-    ;
+  /** The main log buffer. This is the only log buffer available to apps. */
+  LOG_ID_MAIN = 0,
+  /** The radio log buffer. */
+  LOG_ID_RADIO = 1,
+  /** The event log buffer. */
+  LOG_ID_EVENTS = 2,
+  /** The system log buffer. */
+  LOG_ID_SYSTEM = 3,
+  /** The crash log buffer. */
+  LOG_ID_CRASH = 4,
+  /** The statistics log buffer. */
+  LOG_ID_STATS = 5,
+  /** The security log buffer. */
+  LOG_ID_SECURITY = 6,
+  /** The kernel log buffer. */
+  LOG_ID_KERNEL = 7,
 
-/*
- * A variant of __android_log_print() that takes a va_list to list
- * additional parameters.
+  /** For internal use only.  */
+  LOG_ID_MAX,
+
+  /**
+   * Let the logging library choose the best log target in cases where it's
+   * unclear. This is useful if you're generic library code that can't know
+   * which log your caller should use.
+   */
+  LOG_ID_DEFAULT = 0x7FFFFFFF
+} log_id_t;
+
+static inline bool __android_log_id_is_valid(log_id_t log_id) {
+  return log_id >= LOG_ID_MIN && log_id < LOG_ID_MAX;
+}
+
+/**
+ * Writes the constant string `text` to the main log buffer,
+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.
+ *
+ * See __android_log_buf_write() to write to a different log buffer.
+ *
+ * @return 1 if the message was written to the log, or -EPERM if it was not; see
+ * __android_log_is_loggable().
  */
-int __android_log_vprint(int prio, const char *tag,
-                         const char *fmt, va_list ap);
+int __android_log_write(int prio, const char* tag, const char* text);
 
-/*
- * Log an assertion failure and abort the process to have a chance
- * to inspect it if a debugger is attached. This uses the FATAL priority.
- */
-void __android_log_assert(const char *cond, const char *tag,
-                          const char *fmt, ...)
-#if defined(__GNUC__)
-    __attribute__ ((noreturn))
-#ifdef __USE_MINGW_ANSI_STDIO
-#if __USE_MINGW_ANSI_STDIO
-    __attribute__ ((format(gnu_printf, 3, 4)))
-#else
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-#else
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-#endif
-    ;
+/**
+ * Writes the string `text` to the log buffer `log_id` (one of the `log_id_t` values),
+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.
+ *
+ * Apps should use __android_log_write() instead because LOG_ID_MAIN is the
+ * only log buffer available to them.
+ *
+ * @return 1 if the message was written to the log, or -EPERM if it was not; see
+ * __android_log_is_loggable().
+ */
+int __android_log_buf_write(int log_id, int prio, const char* tag, const char* text);
+
+/**
+ * Writes a formatted string to the main log buffer,
+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.
+ *
+ * The details of formatting are the same as for
+ * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html).
+ *
+ * See __android_log_buf_print() to write to a different log buffer.
+ *
+ * @return 1 if the message was written to the log, or -EPERM if it was not; see
+ * __android_log_is_loggable().
+ */
+int __android_log_print(int prio, const char* tag, const char* fmt, ...)
+    __attribute__((__format__(printf, 3, 4)));
+
+/**
+ * Writes a formatted string to the log buffer `log_id` (one of the `log_id_t` values),
+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.
+ *
+ * The details of formatting are the same as for
+ * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html).
+ *
+ * Apps should use __android_log_print() instead because LOG_ID_MAIN is the
+ * only log buffer available to them.
+ *
+ * @return 1 if the message was written to the log, or -EPERM if it was not; see
+ * __android_log_is_loggable().
+ */
+int __android_log_buf_print(int log_id, int prio, const char* tag, const char* fmt, ...)
+    __attribute__((__format__(printf, 4, 5)));
+
+/**
+ * Equivalent to __android_log_print(), but taking a `va_list`.
+ * (If __android_log_print() is like printf(), this is like vprintf().)
+ *
+ * @return 1 if the message was written to the log, or -EPERM if it was not; see
+ * __android_log_is_loggable().
+ */
+int __android_log_vprint(int prio, const char* tag, const char* fmt, va_list ap)
+    __attribute__((__format__(printf, 3, 0)));
+
+/**
+ * Writes an assertion failure to the main log buffer
+ * with priority `ANDROID_LOG_FATAL` -- and also to stderr -- before calling
+ * [abort(3)](http://man7.org/linux/man-pages/man3/abort.3.html).
+ *
+ * If `fmt` is non-null, `cond` is unused. If `fmt` is null, the string
+ * `Assertion failed: %s` is used with `cond` as the string argument.
+ * If both `fmt` and `cond` are null, a default string is provided.
+ *
+ * Most callers should use
+ * [assert(3)](http://man7.org/linux/man-pages/man3/assert.3.html) from
+ * `&lt;assert.h&gt;` instead, or the `__assert` and `__assert2` functions
+ * provided by bionic if more control is needed. They support automatically
+ * including the source filename and line number more conveniently than this
+ * function.
+ */
+void __android_log_assert(const char* cond, const char* tag, const char* fmt, ...)
+    __attribute__((__noreturn__)) __attribute__((__format__(printf, 3, 4)));
+
+/**
+ * Logger data struct used for writing log messages to liblog via __android_log_write_logger_data()
+ * and sending log messages to user defined loggers specified in __android_log_set_logger().
+ */
+struct __android_log_message {
+  /** Must be set to `sizeof(__android_log_message)` and is used for versioning. */
+  size_t struct_size;
+
+  /** {@link log_id_t} values. */
+  int32_t buffer_id;
+
+  /** {@link android_LogPriority} values. */
+  int32_t priority;
+
+  /** The tag for the log message. */
+  const char* tag;
+
+  /** Optional file name, may be set to nullptr. */
+  const char* file;
+
+  /** Optional line number, ignore if file is nullptr. */
+  uint32_t line;
+
+  /** The log message itself. */
+  const char* message;
+};
+
+/**
+ * Prototype for the 'logger' function that is called for every log message.
+ */
+typedef void (*__android_logger_function)(const struct __android_log_message* log_message);
+
+/**
+ * Prototype for the 'abort' function that is called when liblog will abort due to
+ * __android_log_assert() failures.
+ */
+typedef void (*__android_aborter_function)(const char* abort_message);
+
+/**
+ * Writes the log message specified by log_message.  log_message includes additional file name and
+ * line number information that a logger may use.  log_message is versioned for backwards
+ * compatibility.
+ * This assumes that loggability has already been checked through __android_log_is_loggable().
+ * Higher level logging libraries, such as libbase, first check loggability, then format their
+ * buffers, then pass the message to liblog via this function, and therefore we do not want to
+ * duplicate the loggability check here.
+ *
+ * @param log_message the log message itself, see {@link __android_log_message}.
+ *
+ * Available since API level 30.
+ */
+void __android_log_write_log_message(struct __android_log_message* log_message) __INTRODUCED_IN(30);
+
+/**
+ * Sets a user defined logger function.  All log messages sent to liblog will be set to the
+ * function pointer specified by logger for processing.  It is not expected that log messages are
+ * already terminated with a new line.  This function should add new lines if required for line
+ * separation.
+ *
+ * @param logger the new function that will handle log messages.
+ *
+ * Available since API level 30.
+ */
+void __android_log_set_logger(__android_logger_function logger) __INTRODUCED_IN(30);
+
+/**
+ * Writes the log message to logd.  This is an {@link __android_logger_function} and can be provided to
+ * __android_log_set_logger().  It is the default logger when running liblog on a device.
+ *
+ * @param log_message the log message to write, see {@link __android_log_message}.
+ *
+ * Available since API level 30.
+ */
+void __android_log_logd_logger(const struct __android_log_message* log_message) __INTRODUCED_IN(30);
+
+/**
+ * Writes the log message to logd using the passed in timestamp.  The messages are stored
+ * in logd in the order received not in order by timestamp.  When displaying the log, there is no
+ * guarantee that messages are in timestamp order and might cause messages with different times to
+ * be interleaved.  Filtering the log using a timestamp will work properly even if out of time
+ * order messages are present.
+ *
+ * @param log_message the log message to write, see {@link __android_log_message}.
+ * @param timestamp the time to use for this log message. The value is interpreted as a
+ * CLOCK_REALTIME value.
+ *
+ * Available since API level 37.
+ */
+void __android_log_logd_logger_with_timestamp(const struct __android_log_message* log_message,
+                                              const struct timespec* timestamp) __INTRODUCED_IN(37);
+
+/**
+ * Writes the log message to stderr.  This is an {@link __android_logger_function} and can be provided to
+ * __android_log_set_logger().  It is the default logger when running liblog on host.
+ *
+ * @param log_message the log message to write, see {@link __android_log_message}.
+ *
+ * Available since API level 30.
+ */
+void __android_log_stderr_logger(const struct __android_log_message* log_message)
+    __INTRODUCED_IN(30);
+
+/**
+ * Sets a user defined aborter function that is called for __android_log_assert() failures.  This
+ * user defined aborter function is highly recommended to abort and be noreturn, but is not strictly
+ * required to.
+ *
+ * @param aborter the new aborter function, see {@link __android_aborter_function}.
+ *
+ * Available since API level 30.
+ */
+void __android_log_set_aborter(__android_aborter_function aborter) __INTRODUCED_IN(30);
+
+/**
+ * Calls the stored aborter function.  This allows for other logging libraries to use the same
+ * aborter function by calling this function in liblog.
+ *
+ * @param abort_message an additional message supplied when aborting, for example this is used to
+ *                      call android_set_abort_message() in __android_log_default_aborter().
+ *
+ * Available since API level 30.
+ */
+void __android_log_call_aborter(const char* abort_message) __INTRODUCED_IN(30);
+
+/**
+ * Sets android_set_abort_message() on device then aborts().  This is the default aborter.
+ *
+ * @param abort_message an additional message supplied when aborting.  This functions calls
+ *                      android_set_abort_message() with its contents.
+ *
+ * Available since API level 30.
+ */
+void __android_log_default_aborter(const char* abort_message) __attribute__((noreturn))
+__INTRODUCED_IN(30);
+
+/**
+ * Use the per-tag properties "log.tag.<tagname>" along with the minimum priority from
+ * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will
+ * be printed.  A non-zero result indicates yes, zero indicates false.
+ *
+ * If both a priority for a tag and a minimum priority are set by
+ * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the
+ * minimum priority needed to log.  If only one is set, then that value is used to determine the
+ * minimum priority needed.  If none are set, then default_priority is used.
+ *
+ * @param prio         the priority to test, takes {@link android_LogPriority} values.
+ * @param tag          the tag to test.
+ * @param default_prio the default priority to use if no properties or minimum priority are set.
+ * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not.
+ *
+ * Available since API level 30.
+ */
+int __android_log_is_loggable(int prio, const char* tag, int default_prio) __INTRODUCED_IN(30);
+
+/**
+ * Use the per-tag properties "log.tag.<tagname>" along with the minimum priority from
+ * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will
+ * be printed.  A non-zero result indicates yes, zero indicates false.
+ *
+ * If both a priority for a tag and a minimum priority are set by
+ * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the
+ * minimum priority needed to log.  If only one is set, then that value is used to determine the
+ * minimum priority needed.  If none are set, then default_priority is used.
+ *
+ * @param prio         the priority to test, takes {@link android_LogPriority} values.
+ * @param tag          the tag to test.
+ * @param len          the length of the tag.
+ * @param default_prio the default priority to use if no properties or minimum priority are set.
+ * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not.
+ *
+ * Available since API level 30.
+ */
+int __android_log_is_loggable_len(int prio, const char* tag, size_t len, int default_prio)
+    __INTRODUCED_IN(30);
+
+/**
+ * Sets the minimum priority that will be logged for this process.
+ *
+ * @param priority the new minimum priority to set, takes {@link android_LogPriority} values.
+ * @return the previous set minimum priority, or `ANDROID_LOG_DEFAULT` if none was set.
+ *
+ * Available since API level 30.
+ */
+int32_t __android_log_set_minimum_priority(int32_t priority) __INTRODUCED_IN(30);
+
+/**
+ * Gets the minimum priority that will be logged for this process.
+ *
+ * @return the current minimum priority, or `ANDROID_LOG_DEFAULT` if none is set.
+ *
+ * Available since API level 30.
+ */
+int32_t __android_log_get_minimum_priority(void) __INTRODUCED_IN(30);
+
+/**
+ * Sets the default tag if no tag is provided when writing a log message.  Defaults to
+ * getprogname().  This truncates tag to the maximum log message size, though appropriate tags
+ * should be much smaller.
+ *
+ * @param tag the new log tag.
+ *
+ * Available since API level 30.
+ */
+void __android_log_set_default_tag(const char* tag) __INTRODUCED_IN(30);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _ANDROID_LOG_H */
+/** @} */
diff --git a/include/android/system/core/include/cutils/native_handle.h b/include/android/system/core/include/cutils/native_handle.h
index dbd37672f0..d6014efd92 100644
--- a/include/android/system/core/include/cutils/native_handle.h
+++ b/include/android/system/core/include/cutils/native_handle.h
@@ -50,18 +50,28 @@  typedef struct native_handle
 typedef const native_handle_t* buffer_handle_t;
 
 /*
- * native_handle_close
- * 
- * closes the file descriptors contained in this native_handle_t
- * 
+ * Closes the file descriptors contained in this native_handle_t, which may
+ * either be untagged or tagged for ownership by this native_handle_t via
+ * native_handle_set_tag(). Mixing untagged and tagged fds in the same
+ * native_handle_t is not permitted and triggers an fdsan exception, but
+ * native_handle_set_fdsan_tag() can be used to bring consistency if this is
+ * intentional.
+ *
+ * If it's known that fds are tagged, prefer native_handle_close_with_tag() for
+ * better safety.
+ *
  * return 0 on success, or a negative error code on failure
- * 
  */
 int native_handle_close(const native_handle_t* h);
 
 /*
- * native_handle_init
- *
+ * Equivalent to native_handle_close(), but throws an fdsan exception if the fds
+ * are untagged. Use if it's known that the fds in this native_handle_t were
+ * previously tagged via native_handle_set_tag().
+ */
+int native_handle_close_with_tag(const native_handle_t* h);
+
+/*
  * Initializes a native_handle_t from storage.  storage must be declared with
  * NATIVE_HANDLE_DECLARE_STORAGE.  numFds and numInts must not respectively
  * exceed maxFds and maxInts used to declare the storage.
@@ -69,32 +79,42 @@  int native_handle_close(const native_handle_t* h);
 native_handle_t* native_handle_init(char* storage, int numFds, int numInts);
 
 /*
- * native_handle_create
- * 
- * creates a native_handle_t and initializes it. must be destroyed with
- * native_handle_delete().
- * 
+ * Creates a native_handle_t and initializes it. Must be destroyed with
+ * native_handle_delete(). Note that numFds must be <= NATIVE_HANDLE_MAX_FDS,
+ * numInts must be <= NATIVE_HANDLE_MAX_INTS, and both must be >= 0.
  */
 native_handle_t* native_handle_create(int numFds, int numInts);
 
 /*
- * native_handle_clone
- *
- * creates a native_handle_t and initializes it from another native_handle_t.
+ * Updates the fdsan tag for any file descriptors contained in the supplied
+ * handle to indicate that they are owned by this handle and should only be
+ * closed via native_handle_close()/native_handle_close_with_tag(). Each fd in
+ * the handle must have a tag of either 0 (unset) or the tag associated with
+ * this handle, otherwise an fdsan exception will be triggered.
+ */
+void native_handle_set_fdsan_tag(const native_handle_t* handle);
+
+/*
+ * Clears the fdsan tag for any file descriptors contained in the supplied
+ * native_handle_t. Use if this native_handle_t is giving up ownership of its
+ * fds, but the fdsan tags were previously set. Each fd in the handle must have
+ * a tag of either 0 (unset) or the tag associated with this handle, otherwise
+ * an fdsan exception will be triggered.
+ */
+void native_handle_unset_fdsan_tag(const native_handle_t* handle);
+
+/*
+ * Creates a native_handle_t and initializes it from another native_handle_t.
  * Must be destroyed with native_handle_delete().
- *
  */
 native_handle_t* native_handle_clone(const native_handle_t* handle);
 
 /*
- * native_handle_delete
- * 
- * frees a native_handle_t allocated with native_handle_create().
+ * Frees a native_handle_t allocated with native_handle_create().
  * This ONLY frees the memory allocated for the native_handle_t, but doesn't
  * close the file descriptors; which can be achieved with native_handle_close().
- * 
+ *
  * return 0 on success, or a negative error code on failure
- * 
  */
 int native_handle_delete(native_handle_t* h);
 
diff --git a/include/android/system/core/include/system/camera.h b/include/android/system/core/include/system/camera.h
index 9d69588f98..b625aada70 100644
--- a/include/android/system/core/include/system/camera.h
+++ b/include/android/system/core/include/system/camera.h
@@ -159,8 +159,8 @@  enum {
      *
      * When any camera method returns error, the client can use ping command
      * to see if the camera has been taken away by other clients. If the result
-     * is NO_ERROR, it means the camera hardware is not released. If the result
-     * is not NO_ERROR, the camera has been released and the existing client
+     * is OK, it means the camera hardware is not released. If the result
+     * is not OK, the camera has been released and the existing client
      * can silently finish itself or show a dialog.
      */
     CAMERA_CMD_PING = 9,
diff --git a/include/android/system/core/include/system/graphics-base-v1.2.h b/include/android/system/core/include/system/graphics-base-v1.2.h
new file mode 100644
index 0000000000..372284ad73
--- /dev/null
+++ b/include/android/system/core/include/system/graphics-base-v1.2.h
@@ -0,0 +1,36 @@ 
+/* SPDX-License-Identifier: Apache-2.0 */
+// This file is autogenerated by hidl-gen. Do not edit manually.
+// Source: android.hardware.graphics.common@1.2
+// Location: hardware/interfaces/graphics/common/1.2/
+
+#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_
+#define HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    HAL_HDR_HDR10_PLUS = 4,
+} android_hdr_v1_2_t;
+
+typedef enum {
+    HAL_DATASPACE_DISPLAY_BT2020 = 142999552 /* STANDARD_BT2020 | TRANSFER_SRGB | RANGE_FULL */,
+    HAL_DATASPACE_DYNAMIC_DEPTH = 4098 /* 0x1002 */,
+    HAL_DATASPACE_JPEG_APP_SEGMENTS = 4099 /* 0x1003 */,
+    HAL_DATASPACE_HEIF = 4100 /* 0x1004 */,
+} android_dataspace_v1_2_t;
+
+typedef enum {
+    HAL_COLOR_MODE_DISPLAY_BT2020 = 13,
+} android_color_mode_v1_2_t;
+
+typedef enum {
+    HAL_PIXEL_FORMAT_HSV_888 = 55 /* 0x37 */,
+} android_pixel_format_v1_2_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_
diff --git a/include/android/system/core/include/system/graphics-base.h b/include/android/system/core/include/system/graphics-base.h
index d01e9874f9..3db0bbc526 100644
--- a/include/android/system/core/include/system/graphics-base.h
+++ b/include/android/system/core/include/system/graphics-base.h
@@ -4,5 +4,6 @@ 
 
 #include "graphics-base-v1.0.h"
 #include "graphics-base-v1.1.h"
+#include "graphics-base-v1.2.h"
 
 #endif  // SYSTEM_CORE_GRAPHICS_BASE_H_
diff --git a/include/android/system/core/include/system/graphics.h b/include/android/system/core/include/system/graphics.h
index 6341e642d5..34159e127a 100644
--- a/include/android/system/core/include/system/graphics.h
+++ b/include/android/system/core/include/system/graphics.h
@@ -60,12 +60,14 @@  typedef android_hdr_t android_hdr;
 
 /*
  * Structure for describing YCbCr formats for consumption by applications.
- * This is used with HAL_PIXEL_FORMAT_YCbCr_*_888.
+ * This is used with HAL_PIXEL_FORMAT_YCbCr_*.
  *
  * Buffer chroma subsampling is defined in the format.
  * e.g. HAL_PIXEL_FORMAT_YCbCr_420_888 has subsampling 4:2:0.
  *
- * Buffers must have a 8 bit depth.
+ * Buffers must have a byte aligned channel depth or a byte aligned packed
+ * channel depth (e.g. 10 bits packed into 16 bits for
+ * HAL_PIXEL_FORMAT_YCbCr_P010).
  *
  * y, cb, and cr point to the first byte of their respective planes.
  *
@@ -76,8 +78,8 @@  typedef android_hdr_t android_hdr;
  * cstride is the stride of the chroma planes.
  *
  * chroma_step is the distance in bytes from one chroma pixel value to the
- * next.  This is 2 bytes for semiplanar (because chroma values are interleaved
- * and each chroma value is one byte) and 1 for planar.
+ * next.  This is `2 * channel depth` bytes for semiplanar (because chroma
+ * values are interleaved) and `1 * channel depth` bytes for planar.
  */
 
 struct android_ycbcr {
diff --git a/src/android/camera3_hal.cpp b/src/android/camera3_hal.cpp
index a5ad2374a9..ce313ebace 100644
--- a/src/android/camera3_hal.cpp
+++ b/src/android/camera3_hal.cpp
@@ -112,5 +112,8 @@  camera_module_t HAL_MODULE_INFO_SYM = {
 	.open_legacy = hal_open_legacy,
 	.set_torch_mode = hal_set_torch_mode,
 	.init = hal_init,
+	.get_physical_camera_info = nullptr,
+	.is_stream_combination_supported = nullptr,
+	.notify_device_state_change = nullptr,
 	.reserved = {},
 };
diff --git a/src/android/camera_ops.cpp b/src/android/camera_ops.cpp
index ecaac5a31c..1656fac7ab 100644
--- a/src/android/camera_ops.cpp
+++ b/src/android/camera_ops.cpp
@@ -99,5 +99,7 @@  camera3_device_ops hal_dev_ops = {
 	.get_metadata_vendor_tag_ops = nullptr,
 	.dump = hal_dev_dump,
 	.flush = hal_dev_flush,
-	.reserved = { nullptr },
+	.signal_stream_flush = nullptr,
+	.is_reconfiguration_required = nullptr,
+	.reserved = {},
 };
diff --git a/src/android/metadata/camera_metadata.c b/src/android/metadata/camera_metadata.c
index b86586a7e6..fc695bcadd 100644
--- a/src/android/metadata/camera_metadata.c
+++ b/src/android/metadata/camera_metadata.c
@@ -103,10 +103,10 @@  struct camera_metadata {
     uint32_t                 version;
     uint32_t                 flags;
     metadata_size_t          entry_count;
-    metadata_size_t          entry_capacity;
+    metadata_size_t          entry_capacity; // Number of entries that can be stored
     metadata_uptrdiff_t      entries_start; // Offset from camera_metadata
     metadata_size_t          data_count;
-    metadata_size_t          data_capacity;
+    metadata_size_t          data_capacity; // Number of data bytes that can be stored
     metadata_uptrdiff_t      data_start; // Offset from camera_metadata
     uint32_t                 padding;    // padding to 8 bytes boundary
     metadata_vendor_id_t     vendor_id;
@@ -241,7 +241,7 @@  camera_metadata_t *allocate_copy_camera_metadata_checked(
         return NULL;
     }
 
-    void *buffer = malloc(src_size);
+    void *buffer = calloc(1, src_size);
     memcpy(buffer, src, src_size);
 
     camera_metadata_t *metadata = (camera_metadata_t*) buffer;
@@ -258,7 +258,7 @@  camera_metadata_t *allocate_camera_metadata(size_t entry_capacity,
 
     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
                                                           data_capacity);
-    void *buffer = malloc(memory_needed);
+    void *buffer = calloc(1, memory_needed);
     camera_metadata_t *metadata = place_camera_metadata(
         buffer, memory_needed, entry_capacity, data_capacity);
     if (!metadata) {
@@ -278,7 +278,11 @@  camera_metadata_t *place_camera_metadata(void *dst,
 
     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
                                                           data_capacity);
-    if (memory_needed > dst_size) return NULL;
+    if (memory_needed > dst_size) {
+      ALOGE("%s: Memory needed to place camera metadata (%zu) > dst size (%zu)", __FUNCTION__,
+              memory_needed, dst_size);
+      return NULL;
+    }
 
     camera_metadata_t *metadata = (camera_metadata_t*)dst;
     metadata->version = CURRENT_METADATA_VERSION;
@@ -350,7 +354,11 @@  camera_metadata_t* copy_camera_metadata(void *dst, size_t dst_size,
     size_t memory_needed = get_camera_metadata_compact_size(src);
 
     if (dst == NULL) return NULL;
-    if (dst_size < memory_needed) return NULL;
+    if (dst_size < memory_needed) {
+        ALOGE("%s: Memory needed to place camera metadata (%zu) > dst size (%zu)", __FUNCTION__,
+                memory_needed, dst_size);
+      return NULL;
+    }
 
     camera_metadata_t *metadata =
         place_camera_metadata(dst, dst_size, src->entry_count, src->data_count);
@@ -433,14 +441,14 @@  int validate_camera_metadata_structure(const camera_metadata_t *metadata,
         };
 
         for (size_t i = 0; i < sizeof(alignments)/sizeof(alignments[0]); ++i) {
-            uintptr_t aligned_ptr = ALIGN_TO((uintptr_t) metadata + alignmentOffset,
+            uintptr_t aligned_ptr_section = ALIGN_TO((uintptr_t) metadata + alignmentOffset,
                     alignments[i].alignment);
 
-            if ((uintptr_t)metadata + alignmentOffset != aligned_ptr) {
+            if ((uintptr_t)metadata + alignmentOffset != aligned_ptr_section) {
                 ALOGE("%s: Metadata pointer is not aligned (actual %p, "
                       "expected %p, offset %" PRIuPTR ") to type %s",
                       __FUNCTION__, metadata,
-                      (void*)aligned_ptr, alignmentOffset, alignments[i].name);
+                      (void*)aligned_ptr_section, alignmentOffset, alignments[i].name);
                 return CAMERA_METADATA_VALIDATION_ERROR;
             }
         }
@@ -449,56 +457,86 @@  int validate_camera_metadata_structure(const camera_metadata_t *metadata,
     /**
      * Check that the metadata contents are correct
      */
+    if (expected_size != NULL && sizeof(camera_metadata_t) > *expected_size) {
+        ALOGE("%s: Metadata size (%zu) should be <= expected size (%zu)",
+                __FUNCTION__, sizeof(camera_metadata_t), *expected_size);
+        return CAMERA_METADATA_VALIDATION_ERROR;
+    }
+
+    // Create an aligned header
+    camera_metadata_t headerCopy;
+    const camera_metadata_t *header;
+    if (alignmentOffset != 0) {
+        memcpy(&headerCopy, metadata, sizeof(camera_metadata_t));
+        header = &headerCopy;
+    } else {
+        header = metadata;
+    }
 
-    if (expected_size != NULL && metadata->size > *expected_size) {
+    if (expected_size != NULL && header->size > *expected_size) {
         ALOGE("%s: Metadata size (%" PRIu32 ") should be <= expected size (%zu)",
-              __FUNCTION__, metadata->size, *expected_size);
+              __FUNCTION__, header->size, *expected_size);
         return CAMERA_METADATA_VALIDATION_ERROR;
     }
 
-    if (metadata->entry_count > metadata->entry_capacity) {
+    if (header->entry_count > header->entry_capacity) {
         ALOGE("%s: Entry count (%" PRIu32 ") should be <= entry capacity "
               "(%" PRIu32 ")",
-              __FUNCTION__, metadata->entry_count, metadata->entry_capacity);
+              __FUNCTION__, header->entry_count, header->entry_capacity);
         return CAMERA_METADATA_VALIDATION_ERROR;
     }
 
-    if (metadata->data_count > metadata->data_capacity) {
+    if (header->data_count > header->data_capacity) {
         ALOGE("%s: Data count (%" PRIu32 ") should be <= data capacity "
               "(%" PRIu32 ")",
-              __FUNCTION__, metadata->data_count, metadata->data_capacity);
+              __FUNCTION__, header->data_count, header->data_capacity);
         // android_errorWriteLog(SN_EVENT_LOG_ID, "30591838");
         return CAMERA_METADATA_VALIDATION_ERROR;
     }
 
+    // Check for overflow when calculating entry capacity bytes.
+    // (metadata_size_t)~0 represents the maximum representable value of metadata_size_t.
+    if (header->entry_capacity > (metadata_size_t)~0 / sizeof(camera_metadata_buffer_entry_t)) {
+        ALOGE("%s: Entry capacity (%" PRIu32 ") is too large",
+              __FUNCTION__, header->entry_capacity);
+        return CAMERA_METADATA_VALIDATION_ERROR;
+    }
+
+    metadata_size_t entries_capacity_bytes =
+            sizeof(camera_metadata_buffer_entry_t) * header->entry_capacity;
     const metadata_uptrdiff_t entries_end =
-        metadata->entries_start + metadata->entry_capacity;
-    if (entries_end < metadata->entries_start || // overflow check
-        entries_end > metadata->data_start) {
+        header->entries_start + entries_capacity_bytes;
+
+    if (entries_end < header->entries_start) {
+        ALOGE("%s: Entry start (%" PRIu32 ") + capacity bytes (%" PRIu32 ") "
+              "overflows", __FUNCTION__, header->entries_start, entries_capacity_bytes);
+        return CAMERA_METADATA_VALIDATION_ERROR;
+    }
 
+    if (entries_end > header->data_start) {
         ALOGE("%s: Entry start + capacity (%" PRIu32 ") should be <= data start "
               "(%" PRIu32 ")",
                __FUNCTION__,
-              (metadata->entries_start + metadata->entry_capacity),
-              metadata->data_start);
+              entries_end,
+              header->data_start);
         return CAMERA_METADATA_VALIDATION_ERROR;
     }
 
     const metadata_uptrdiff_t data_end =
-        metadata->data_start + metadata->data_capacity;
-    if (data_end < metadata->data_start || // overflow check
-        data_end > metadata->size) {
+        header->data_start + header->data_capacity;
+    if (data_end < header->data_start || // overflow check
+        data_end > header->size) {
 
         ALOGE("%s: Data start + capacity (%" PRIu32 ") should be <= total size "
               "(%" PRIu32 ")",
                __FUNCTION__,
-              (metadata->data_start + metadata->data_capacity),
-              metadata->size);
+              (header->data_start + header->data_capacity),
+              header->size);
         return CAMERA_METADATA_VALIDATION_ERROR;
     }
 
     // Validate each entry
-    const metadata_size_t entry_count = metadata->entry_count;
+    const metadata_size_t entry_count = header->entry_count;
     camera_metadata_buffer_entry_t *entries = get_entries(metadata);
 
     for (size_t i = 0; i < entry_count; ++i) {
@@ -511,7 +549,12 @@  int validate_camera_metadata_structure(const camera_metadata_t *metadata,
             return CAMERA_METADATA_VALIDATION_ERROR;
         }
 
-        camera_metadata_buffer_entry_t entry = entries[i];
+        camera_metadata_buffer_entry_t entry;
+        if (alignmentOffset != 0) {
+            memcpy(&entry, entries + i, sizeof(camera_metadata_buffer_entry_t));
+        } else {
+            entry = entries[i];
+        }
 
         if (entry.type >= NUM_TYPES) {
             ALOGE("%s: Entry index %zu had a bad type %d",
@@ -522,10 +565,10 @@  int validate_camera_metadata_structure(const camera_metadata_t *metadata,
         // TODO: fix vendor_tag_ops across processes so we don't need to special
         //       case vendor-specific tags
         uint32_t tag_section = entry.tag >> 16;
-        int tag_type = get_local_camera_metadata_tag_type(entry.tag, metadata);
+        int tag_type = get_local_camera_metadata_tag_type(entry.tag, header);
         if (tag_type != (int)entry.type && tag_section < VENDOR_SECTION) {
-            ALOGE("%s: Entry index %zu had tag type %d, but the type was %d",
-                  __FUNCTION__, i, tag_type, entry.type);
+            ALOGE("%s: Entry index %zu (0x%x) had tag type %d, but the type was %d",
+                  __FUNCTION__, i, entry.tag, tag_type, entry.type);
             return CAMERA_METADATA_VALIDATION_ERROR;
         }
 
@@ -1005,6 +1048,15 @@  int get_local_camera_metadata_tag_type(uint32_t tag,
     return get_local_camera_metadata_tag_type_vendor_id(tag, id);
 }
 
+const int32_t *get_camera_metadata_permission_needed(uint32_t *tag_count) {
+    if (NULL == tag_count) {
+        return NULL;
+    }
+
+    *tag_count = sizeof(tag_permission_needed) / sizeof(tag_permission_needed[0]);
+    return tag_permission_needed;
+}
+
 int set_camera_metadata_vendor_tag_ops(const vendor_tag_query_ops_t* ops) {
     // **DEPRECATED**
     (void) ops;
@@ -1046,8 +1098,7 @@  metadata_vendor_id_t get_camera_metadata_vendor_id(
 }
 
 static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type,
-        int count,
-        int indentation);
+        metadata_vendor_id_t vendor_id, int count, int indentation);
 
 void dump_camera_metadata(const camera_metadata_t *metadata,
         int fd,
@@ -1120,12 +1171,13 @@  void dump_indented_camera_metadata(const camera_metadata_t *metadata,
         int count = entry->count;
         if (verbosity < 2 && count > 16) count = 16;
 
-        print_data(fd, data_ptr, entry->tag, entry->type, count, indentation);
+        print_data(fd, data_ptr, entry->tag, entry->type, get_camera_metadata_vendor_id(metadata),
+                   count, indentation);
     }
 }
 
-static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,
-        int type, int count, int indentation) {
+static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type,
+        metadata_vendor_id_t vendor_id, int count, int indentation) {
     static int values_per_line[NUM_TYPES] = {
         [TYPE_BYTE]     = 16,
         [TYPE_INT32]    = 4,
@@ -1137,6 +1189,33 @@  static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,
     size_t type_size = camera_metadata_type_size[type];
     char value_string_tmp[CAMERA_METADATA_ENUM_STRING_MAX_SIZE];
     uint32_t value;
+    size_t value_offset;
+    size_t entry_size;
+    // It is possible that the tag value is only found at specific
+    // offset. The rest of the data must not be enumerated.
+    switch (tag) {
+        case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS:
+        case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS:
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS:
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS:
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS:
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:
+        case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS:
+            value_offset = 3 * type_size;
+            entry_size = 4 * type_size;
+            break;
+        case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS:
+            value_offset = 4 * type_size;
+            entry_size = 5 * type_size;
+            break;
+        default:
+            value_offset = 0;
+            entry_size = 0;
+    }
 
     int lines = count / values_per_line[type];
     if (count % values_per_line[type] != 0) lines++;
@@ -1158,14 +1237,24 @@  static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,
                                                      sizeof(value_string_tmp))
                         == OK) {
                         dprintf(fd, "%s ", value_string_tmp);
+                    } else if (tag == ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS) {
+                        if (value != 0) {
+                            dprintf(fd, "%c ",
+                                    *(data_ptr + index));
+                        }
                     } else {
                         dprintf(fd, "%hhu ",
                                 *(data_ptr + index));
                     }
                     break;
                 case TYPE_INT32:
-                    value =
-                            *(int32_t*)(data_ptr + index);
+                    value = *(int32_t*)(data_ptr + index);
+
+                    if ((entry_size > 0) && ((index % entry_size ) != value_offset)) {
+                        dprintf(fd, "%" PRId32 " ", value);
+                        break;
+                    }
+
                     if (camera_metadata_enum_snprint(tag,
                                                      value,
                                                      value_string_tmp,
@@ -1173,8 +1262,24 @@  static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,
                         == OK) {
                         dprintf(fd, "%s ", value_string_tmp);
                     } else {
-                        dprintf(fd, "%" PRId32 " ",
-                                *(int32_t*)(data_ptr + index));
+                        dprintf(fd, "%" PRId32 " ", value);
+                        if (tag == ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS ||
+                            tag == ANDROID_REQUEST_AVAILABLE_RESULT_KEYS ||
+                            tag == ANDROID_REQUEST_AVAILABLE_SESSION_KEYS ||
+                            tag == ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS ||
+                            tag == ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS) {
+                            const char *camera_metadata_tag_name =
+                                get_camera_metadata_tag_name(value);
+                            if (camera_metadata_tag_name != NULL) {
+                                dprintf(fd, "(%s) ", camera_metadata_tag_name);
+                            } else {
+                                const char *camera_metadata_tag_vendor_id =
+                                    get_local_camera_metadata_tag_name_vendor_id(value, vendor_id);
+                                if (camera_metadata_tag_vendor_id != NULL) {
+                                    dprintf(fd, "(%s) ", camera_metadata_tag_vendor_id);
+                                }
+                            }
+                        }
                     }
                     break;
                 case TYPE_FLOAT:
diff --git a/src/android/metadata/camera_metadata_tag_info.c b/src/android/metadata/camera_metadata_tag_info.c
index e1b81f6d15..3db3bb7f55 100644
--- a/src/android/metadata/camera_metadata_tag_info.c
+++ b/src/android/metadata/camera_metadata_tag_info.c
@@ -61,6 +61,14 @@  const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {
     [ANDROID_LOGICAL_MULTI_CAMERA] = "android.logicalMultiCamera",
     [ANDROID_DISTORTION_CORRECTION]
                                     = "android.distortionCorrection",
+    [ANDROID_HEIC]                 = "android.heic",
+    [ANDROID_HEIC_INFO]            = "android.heic.info",
+    [ANDROID_AUTOMOTIVE]           = "android.automotive",
+    [ANDROID_AUTOMOTIVE_LENS]      = "android.automotive.lens",
+    [ANDROID_EXTENSION]            = "android.extension",
+    [ANDROID_JPEGR]                = "android.jpegr",
+    [ANDROID_SHARED_SESSION]       = "android.sharedSession",
+    [ANDROID_DESKTOP_EFFECTS]      = "android.desktopEffects",
 };
 
 unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
@@ -121,6 +129,22 @@  unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
     [ANDROID_DISTORTION_CORRECTION]
                                     = { ANDROID_DISTORTION_CORRECTION_START,
                                        ANDROID_DISTORTION_CORRECTION_END },
+    [ANDROID_HEIC]                 = { ANDROID_HEIC_START,
+                                       ANDROID_HEIC_END },
+    [ANDROID_HEIC_INFO]            = { ANDROID_HEIC_INFO_START,
+                                       ANDROID_HEIC_INFO_END },
+    [ANDROID_AUTOMOTIVE]           = { ANDROID_AUTOMOTIVE_START,
+                                       ANDROID_AUTOMOTIVE_END },
+    [ANDROID_AUTOMOTIVE_LENS]      = { ANDROID_AUTOMOTIVE_LENS_START,
+                                       ANDROID_AUTOMOTIVE_LENS_END },
+    [ANDROID_EXTENSION]            = { ANDROID_EXTENSION_START,
+                                       ANDROID_EXTENSION_END },
+    [ANDROID_JPEGR]                = { ANDROID_JPEGR_START,
+                                       ANDROID_JPEGR_END },
+    [ANDROID_SHARED_SESSION]       = { ANDROID_SHARED_SESSION_START,
+                                       ANDROID_SHARED_SESSION_END },
+    [ANDROID_DESKTOP_EFFECTS]      = { ANDROID_DESKTOP_EFFECTS_START,
+                                       ANDROID_DESKTOP_EFFECTS_END },
 };
 
 static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -
@@ -136,6 +160,14 @@  static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -
     { "aberrationMode",                TYPE_BYTE   },
     [ ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES - ANDROID_COLOR_CORRECTION_START ] =
     { "availableAberrationModes",      TYPE_BYTE   },
+    [ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE - ANDROID_COLOR_CORRECTION_START ] =
+    { "colorTemperature",              TYPE_INT32  },
+    [ ANDROID_COLOR_CORRECTION_COLOR_TINT - ANDROID_COLOR_CORRECTION_START ] =
+    { "colorTint",                     TYPE_INT32  },
+    [ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE - ANDROID_COLOR_CORRECTION_START ] =
+    { "colorTemperatureRange",         TYPE_INT32  },
+    [ ANDROID_COLOR_CORRECTION_AVAILABLE_MODES - ANDROID_COLOR_CORRECTION_START ] =
+    { "availableModes",                TYPE_BYTE   },
 };
 
 static tag_info_t android_control[ANDROID_CONTROL_END -
@@ -229,6 +261,50 @@  static tag_info_t android_control[ANDROID_CONTROL_END -
     { "enableZsl",                     TYPE_BYTE   },
     [ ANDROID_CONTROL_AF_SCENE_CHANGE - ANDROID_CONTROL_START ] =
     { "afSceneChange",                 TYPE_BYTE   },
+    [ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES - ANDROID_CONTROL_START ] =
+    { "availableExtendedSceneModeMaxSizes",
+                                        TYPE_INT32  },
+    [ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES - ANDROID_CONTROL_START ] =
+    { "availableExtendedSceneModeZoomRatioRanges",
+                                        TYPE_FLOAT  },
+    [ ANDROID_CONTROL_EXTENDED_SCENE_MODE - ANDROID_CONTROL_START ] =
+    { "extendedSceneMode",             TYPE_BYTE   },
+    [ ANDROID_CONTROL_ZOOM_RATIO_RANGE - ANDROID_CONTROL_START ] =
+    { "zoomRatioRange",                TYPE_FLOAT  },
+    [ ANDROID_CONTROL_ZOOM_RATIO - ANDROID_CONTROL_START ] =
+    { "zoomRatio",                     TYPE_FLOAT  },
+    [ ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_CONTROL_START ] =
+    { "availableHighSpeedVideoConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_CONTROL_AF_REGIONS_SET - ANDROID_CONTROL_START ] =
+    { "afRegionsSet",                  TYPE_BYTE   },
+    [ ANDROID_CONTROL_AE_REGIONS_SET - ANDROID_CONTROL_START ] =
+    { "aeRegionsSet",                  TYPE_BYTE   },
+    [ ANDROID_CONTROL_AWB_REGIONS_SET - ANDROID_CONTROL_START ] =
+    { "awbRegionsSet",                 TYPE_BYTE   },
+    [ ANDROID_CONTROL_SETTINGS_OVERRIDE - ANDROID_CONTROL_START ] =
+    { "settingsOverride",              TYPE_INT32  },
+    [ ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES - ANDROID_CONTROL_START ] =
+    { "availableSettingsOverrides",    TYPE_INT32  },
+    [ ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER - ANDROID_CONTROL_START ] =
+    { "settingsOverridingFrameNumber", TYPE_INT32  },
+    [ ANDROID_CONTROL_AUTOFRAMING - ANDROID_CONTROL_START ] =
+    { "autoframing",                   TYPE_BYTE   },
+    [ ANDROID_CONTROL_AUTOFRAMING_AVAILABLE - ANDROID_CONTROL_START ] =
+    { "autoframingAvailable",          TYPE_BYTE   },
+    [ ANDROID_CONTROL_AUTOFRAMING_STATE - ANDROID_CONTROL_START ] =
+    { "autoframingState",              TYPE_BYTE   },
+    [ ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE - ANDROID_CONTROL_START ] =
+    { "lowLightBoostInfoLuminanceRange",
+                                        TYPE_FLOAT  },
+    [ ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE - ANDROID_CONTROL_START ] =
+    { "lowLightBoostState",            TYPE_BYTE   },
+    [ ANDROID_CONTROL_ZOOM_METHOD - ANDROID_CONTROL_START ] =
+    { "zoomMethod",                    TYPE_BYTE   },
+    [ ANDROID_CONTROL_AE_PRIORITY_MODE - ANDROID_CONTROL_START ] =
+    { "aePriorityMode",                TYPE_BYTE   },
+    [ ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES - ANDROID_CONTROL_START ] =
+    { "aeAvailablePriorityModes",      TYPE_BYTE   },
 };
 
 static tag_info_t android_demosaic[ANDROID_DEMOSAIC_END -
@@ -261,6 +337,16 @@  static tag_info_t android_flash[ANDROID_FLASH_END -
     { "maxEnergy",                     TYPE_BYTE   },
     [ ANDROID_FLASH_STATE - ANDROID_FLASH_START ] =
     { "state",                         TYPE_BYTE   },
+    [ ANDROID_FLASH_STRENGTH_LEVEL - ANDROID_FLASH_START ] =
+    { "strengthLevel",                 TYPE_INT32  },
+    [ ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL - ANDROID_FLASH_START ] =
+    { "singleStrengthMaxLevel",        TYPE_INT32  },
+    [ ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_START ] =
+    { "singleStrengthDefaultLevel",    TYPE_INT32  },
+    [ ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL - ANDROID_FLASH_START ] =
+    { "torchStrengthMaxLevel",         TYPE_INT32  },
+    [ ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_START ] =
+    { "torchStrengthDefaultLevel",     TYPE_INT32  },
 };
 
 static tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -
@@ -269,6 +355,10 @@  static tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -
     { "available",                     TYPE_BYTE   },
     [ ANDROID_FLASH_INFO_CHARGE_DURATION - ANDROID_FLASH_INFO_START ] =
     { "chargeDuration",                TYPE_INT64  },
+    [ ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL - ANDROID_FLASH_INFO_START ] =
+    { "strengthMaximumLevel",          TYPE_INT32  },
+    [ ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_INFO_START ] =
+    { "strengthDefaultLevel",          TYPE_INT32  },
 };
 
 static tag_info_t android_hot_pixel[ANDROID_HOT_PIXEL_END -
@@ -333,6 +423,11 @@  static tag_info_t android_lens[ANDROID_LENS_END -
     { "poseReference",                 TYPE_BYTE   },
     [ ANDROID_LENS_DISTORTION - ANDROID_LENS_START ] =
     { "distortion",                    TYPE_FLOAT  },
+    [ ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION - ANDROID_LENS_START ] =
+    { "distortionMaximumResolution",   TYPE_FLOAT  },
+    [ ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION - ANDROID_LENS_START ] =
+    { "intrinsicCalibrationMaximumResolution",
+                                        TYPE_FLOAT  },
 };
 
 static tag_info_t android_lens_info[ANDROID_LENS_INFO_END -
@@ -418,6 +513,18 @@  static tag_info_t android_request[ANDROID_REQUEST_END -
     [ ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS - ANDROID_REQUEST_START ] =
     { "availablePhysicalCameraRequestKeys",
                                         TYPE_INT32  },
+    [ ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION - ANDROID_REQUEST_START ] =
+    { "characteristicKeysNeedingPermission",
+                                        TYPE_INT32  },
+    [ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP - ANDROID_REQUEST_START ] =
+    { "availableDynamicRangeProfilesMap",
+                                        TYPE_INT64  },
+    [ ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE - ANDROID_REQUEST_START ] =
+    { "recommendedTenBitDynamicRangeProfile",
+                                        TYPE_INT64  },
+    [ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP - ANDROID_REQUEST_START ] =
+    { "availableColorSpaceProfilesMap",
+                                        TYPE_INT64  },
 };
 
 static tag_info_t android_scaler[ANDROID_SCALER_END -
@@ -452,6 +559,45 @@  static tag_info_t android_scaler[ANDROID_SCALER_END -
     { "availableStallDurations",       TYPE_INT64  },
     [ ANDROID_SCALER_CROPPING_TYPE - ANDROID_SCALER_START ] =
     { "croppingType",                  TYPE_BYTE   },
+    [ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS - ANDROID_SCALER_START ] =
+    { "availableRecommendedStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP - ANDROID_SCALER_START ] =
+    { "availableRecommendedInputOutputFormatsMap",
+                                        TYPE_INT32  },
+    [ ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES - ANDROID_SCALER_START ] =
+    { "availableRotateAndCropModes",   TYPE_BYTE   },
+    [ ANDROID_SCALER_ROTATE_AND_CROP - ANDROID_SCALER_START ] =
+    { "rotateAndCrop",                 TYPE_BYTE   },
+    [ ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE - ANDROID_SCALER_START ] =
+    { "defaultSecureImageSize",        TYPE_INT32  },
+    [ ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS - ANDROID_SCALER_START ] =
+    { "physicalCameraMultiResolutionStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =
+    { "availableStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =
+    { "availableMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =
+    { "availableStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =
+    { "availableInputOutputFormatsMapMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED - ANDROID_SCALER_START ] =
+    { "multiResolutionStreamSupported",
+                                        TYPE_BYTE   },
+    [ ANDROID_SCALER_CROP_REGION_SET - ANDROID_SCALER_START ] =
+    { "cropRegionSet",                 TYPE_BYTE   },
+    [ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES - ANDROID_SCALER_START ] =
+    { "availableStreamUseCases",       TYPE_INT64  },
+    [ ANDROID_SCALER_RAW_CROP_REGION - ANDROID_SCALER_START ] =
+    { "rawCropRegion",                 TYPE_INT32  },
+    [ ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS - ANDROID_SCALER_START ] =
+    { "concurrentMultiResolutionFormats",
+                                        TYPE_INT32  },
 };
 
 static tag_info_t android_sensor[ANDROID_SENSOR_END -
@@ -526,6 +672,15 @@  static tag_info_t android_sensor[ANDROID_SENSOR_END -
     { "dynamicWhiteLevel",             TYPE_INT32  },
     [ ANDROID_SENSOR_OPAQUE_RAW_SIZE - ANDROID_SENSOR_START ] =
     { "opaqueRawSize",                 TYPE_INT32  },
+    [ ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_START ] =
+    { "opaqueRawSizeMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SENSOR_PIXEL_MODE - ANDROID_SENSOR_START ] =
+    { "pixelMode",                     TYPE_BYTE   },
+    [ ANDROID_SENSOR_RAW_BINNING_FACTOR_USED - ANDROID_SENSOR_START ] =
+    { "rawBinningFactorUsed",          TYPE_BYTE   },
+    [ ANDROID_SENSOR_READOUT_TIMESTAMP - ANDROID_SENSOR_START ] =
+    { "readoutTimestamp",              TYPE_BYTE   },
 };
 
 static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -
@@ -552,6 +707,17 @@  static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -
     { "lensShadingApplied",            TYPE_BYTE   },
     [ ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE - ANDROID_SENSOR_INFO_START ] =
     { "preCorrectionActiveArraySize",  TYPE_INT32  },
+    [ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =
+    { "activeArraySizeMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =
+    { "pixelArraySizeMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =
+    { "preCorrectionActiveArraySizeMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_SENSOR_INFO_BINNING_FACTOR - ANDROID_SENSOR_INFO_START ] =
+    { "binningFactor",                 TYPE_INT32  },
 };
 
 static tag_info_t android_shading[ANDROID_SHADING_END -
@@ -609,6 +775,10 @@  static tag_info_t android_statistics[ANDROID_STATISTICS_END -
     { "oisXShifts",                    TYPE_FLOAT  },
     [ ANDROID_STATISTICS_OIS_Y_SHIFTS - ANDROID_STATISTICS_START ] =
     { "oisYShifts",                    TYPE_FLOAT  },
+    [ ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS - ANDROID_STATISTICS_START ] =
+    { "lensIntrinsicTimestamps",       TYPE_INT64  },
+    [ ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES - ANDROID_STATISTICS_START ] =
+    { "lensIntrinsicSamples",          TYPE_FLOAT  },
 };
 
 static tag_info_t android_statistics_info[ANDROID_STATISTICS_INFO_END -
@@ -667,6 +837,18 @@  static tag_info_t android_info[ANDROID_INFO_END -
     { "supportedHardwareLevel",        TYPE_BYTE   },
     [ ANDROID_INFO_VERSION - ANDROID_INFO_START ] =
     { "version",                       TYPE_BYTE   },
+    [ ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION - ANDROID_INFO_START ] =
+    { "supportedBufferManagementVersion",
+                                        TYPE_BYTE   },
+    [ ANDROID_INFO_DEVICE_STATE_ORIENTATIONS - ANDROID_INFO_START ] =
+    { "deviceStateOrientations",       TYPE_INT64  },
+    [ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION - ANDROID_INFO_START ] =
+    { "sessionConfigurationQueryVersion",
+                                        TYPE_INT32  },
+    [ ANDROID_INFO_DEVICE_ID - ANDROID_INFO_START ] =
+    { "deviceId",                      TYPE_INT32  },
+    [ ANDROID_INFO_DEVICE_TYPE - ANDROID_INFO_START ] =
+    { "deviceType",                    TYPE_BYTE   },
 };
 
 static tag_info_t android_black_level[ANDROID_BLACK_LEVEL_END -
@@ -705,6 +887,36 @@  static tag_info_t android_depth[ANDROID_DEPTH_END -
     { "availableDepthStallDurations",  TYPE_INT64  },
     [ ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE - ANDROID_DEPTH_START ] =
     { "depthIsExclusive",              TYPE_BYTE   },
+    [ ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS - ANDROID_DEPTH_START ] =
+    { "availableRecommendedDepthStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthMinFrameDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthStallDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDepthStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDepthMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDepthStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =
+    { "availableDynamicDepthStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
 };
 
 static tag_info_t android_logical_multi_camera[ANDROID_LOGICAL_MULTI_CAMERA_END -
@@ -713,6 +925,13 @@  static tag_info_t android_logical_multi_camera[ANDROID_LOGICAL_MULTI_CAMERA_END
     { "physicalIds",                   TYPE_BYTE   },
     [ ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE - ANDROID_LOGICAL_MULTI_CAMERA_START ] =
     { "sensorSyncType",                TYPE_BYTE   },
+    [ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID - ANDROID_LOGICAL_MULTI_CAMERA_START ] =
+    { "activePhysicalId",              TYPE_BYTE   },
+    [ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION - ANDROID_LOGICAL_MULTI_CAMERA_START ] =
+    { "activePhysicalSensorCropRegion",
+                                        TYPE_INT32  },
+    [ ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS - ANDROID_LOGICAL_MULTI_CAMERA_START ] =
+    { "additionalResults",             TYPE_BYTE   },
 };
 
 static tag_info_t android_distortion_correction[ANDROID_DISTORTION_CORRECTION_END -
@@ -723,6 +942,120 @@  static tag_info_t android_distortion_correction[ANDROID_DISTORTION_CORRECTION_EN
     { "availableModes",                TYPE_BYTE   },
 };
 
+static tag_info_t android_heic[ANDROID_HEIC_END -
+        ANDROID_HEIC_START] = {
+    [ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicMinFrameDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicStallDurations",   TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrMinFrameDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrStallDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =
+    { "availableHeicUltraHdrStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
+};
+
+static tag_info_t android_heic_info[ANDROID_HEIC_INFO_END -
+        ANDROID_HEIC_INFO_START] = {
+    [ ANDROID_HEIC_INFO_SUPPORTED - ANDROID_HEIC_INFO_START ] =
+    { "supported",                     TYPE_BYTE   },
+    [ ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT - ANDROID_HEIC_INFO_START ] =
+    { "maxJpegAppSegmentsCount",       TYPE_BYTE   },
+};
+
+static tag_info_t android_automotive[ANDROID_AUTOMOTIVE_END -
+        ANDROID_AUTOMOTIVE_START] = {
+    [ ANDROID_AUTOMOTIVE_LOCATION - ANDROID_AUTOMOTIVE_START ] =
+    { "location",                      TYPE_BYTE   },
+};
+
+static tag_info_t android_automotive_lens[ANDROID_AUTOMOTIVE_LENS_END -
+        ANDROID_AUTOMOTIVE_LENS_START] = {
+    [ ANDROID_AUTOMOTIVE_LENS_FACING - ANDROID_AUTOMOTIVE_LENS_START ] =
+    { "facing",                        TYPE_BYTE   },
+};
+
+static tag_info_t android_extension[ANDROID_EXTENSION_END -
+        ANDROID_EXTENSION_START] = {
+    [ ANDROID_EXTENSION_STRENGTH - ANDROID_EXTENSION_START ] =
+    { "strength",                      TYPE_INT32  },
+    [ ANDROID_EXTENSION_CURRENT_TYPE - ANDROID_EXTENSION_START ] =
+    { "currentType",                   TYPE_INT32  },
+    [ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR - ANDROID_EXTENSION_START ] =
+    { "nightModeIndicator",            TYPE_INT32  },
+};
+
+static tag_info_t android_jpegr[ANDROID_JPEGR_END -
+        ANDROID_JPEGR_START] = {
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS - ANDROID_JPEGR_START ] =
+    { "availableJpegRStreamConfigurations",
+                                        TYPE_INT32  },
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS - ANDROID_JPEGR_START ] =
+    { "availableJpegRMinFrameDurations",
+                                        TYPE_INT64  },
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS - ANDROID_JPEGR_START ] =
+    { "availableJpegRStallDurations",  TYPE_INT64  },
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =
+    { "availableJpegRStreamConfigurationsMaximumResolution",
+                                        TYPE_INT32  },
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =
+    { "availableJpegRMinFrameDurationsMaximumResolution",
+                                        TYPE_INT64  },
+    [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =
+    { "availableJpegRStallDurationsMaximumResolution",
+                                        TYPE_INT64  },
+};
+
+static tag_info_t android_shared_session[ANDROID_SHARED_SESSION_END -
+        ANDROID_SHARED_SESSION_START] = {
+    [ ANDROID_SHARED_SESSION_COLOR_SPACE - ANDROID_SHARED_SESSION_START ] =
+    { "colorSpace",                    TYPE_INT32  },
+    [ ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS - ANDROID_SHARED_SESSION_START ] =
+    { "outputConfigurations",          TYPE_INT64  },
+};
+
+static tag_info_t android_desktop_effects[ANDROID_DESKTOP_EFFECTS_END -
+        ANDROID_DESKTOP_EFFECTS_START] = {
+    [ ANDROID_DESKTOP_EFFECTS_CAPABILITIES - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "capabilities",                  TYPE_BYTE   },
+    [ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "backgroundBlurModes",           TYPE_BYTE   },
+    [ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "backgroundBlurMode",            TYPE_BYTE   },
+    [ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "faceRetouchMode",               TYPE_BYTE   },
+    [ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "faceRetouchStrength",           TYPE_BYTE   },
+    [ ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE - ANDROID_DESKTOP_EFFECTS_START ] =
+    { "portraitRelightMode",           TYPE_BYTE   },
+};
+
 
 tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
     android_color_correction,
@@ -753,6 +1086,35 @@  tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
     android_depth,
     android_logical_multi_camera,
     android_distortion_correction,
+    android_heic,
+    android_heic_info,
+    android_automotive,
+    android_automotive_lens,
+    android_extension,
+    android_jpegr,
+    android_shared_session,
+    android_desktop_effects,
+};
+
+static int32_t tag_permission_needed[18] = {
+    ANDROID_LENS_POSE_ROTATION,
+    ANDROID_LENS_POSE_TRANSLATION,
+    ANDROID_LENS_INTRINSIC_CALIBRATION,
+    ANDROID_LENS_RADIAL_DISTORTION,
+    ANDROID_LENS_POSE_REFERENCE,
+    ANDROID_LENS_DISTORTION,
+    ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION,
+    ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION,
+    ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
+    ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
+    ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
+    ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
+    ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
+    ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
+    ANDROID_SENSOR_COLOR_TRANSFORM1,
+    ANDROID_SENSOR_COLOR_TRANSFORM2,
+    ANDROID_SENSOR_FORWARD_MATRIX1,
+    ANDROID_SENSOR_FORWARD_MATRIX2,
 };
 
 int camera_metadata_enum_snprint(uint32_t tag,
@@ -777,6 +1139,10 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "HIGH_QUALITY";
                     ret = 0;
                     break;
+                case ANDROID_COLOR_CORRECTION_MODE_CCT:
+                    msg = "CCT";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -810,6 +1176,18 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES: {
             break;
         }
+        case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_COLOR_TINT: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_AVAILABLE_MODES: {
+            break;
+        }
 
         case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {
             switch (value) {
@@ -878,6 +1256,10 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "ON_EXTERNAL_FLASH";
                     ret = 0;
                     break;
+                case ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY:
+                    msg = "ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1122,6 +1504,10 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "OFF_KEEP_STATE";
                     ret = 0;
                     break;
+                case ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE:
+                    msg = "USE_EXTENDED_SCENE_MODE";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1232,6 +1618,10 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "ON";
                     ret = 0;
                     break;
+                case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION:
+                    msg = "PREVIEW_STABILIZATION";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1440,6 +1830,222 @@  int camera_metadata_enum_snprint(uint32_t tag,
             }
             break;
         }
+        case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES: {
+            break;
+        }
+        case ANDROID_CONTROL_EXTENDED_SCENE_MODE: {
+            switch (value) {
+                case ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED:
+                    msg = "DISABLED";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE:
+                    msg = "BOKEH_STILL_CAPTURE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS:
+                    msg = "BOKEH_CONTINUOUS";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START:
+                    msg = "VENDOR_START";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_RATIO_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_RATIO: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_CONTROL_AF_REGIONS_SET: {
+            switch (value) {
+                case ANDROID_CONTROL_AF_REGIONS_SET_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AF_REGIONS_SET_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AE_REGIONS_SET: {
+            switch (value) {
+                case ANDROID_CONTROL_AE_REGIONS_SET_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AE_REGIONS_SET_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_REGIONS_SET: {
+            switch (value) {
+                case ANDROID_CONTROL_AWB_REGIONS_SET_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AWB_REGIONS_SET_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_SETTINGS_OVERRIDE: {
+            switch (value) {
+                case ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM:
+                    msg = "ZOOM";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START:
+                    msg = "VENDOR_START";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES: {
+            break;
+        }
+        case ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER: {
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING: {
+            switch (value) {
+                case ANDROID_CONTROL_AUTOFRAMING_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AUTOFRAMING_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AUTOFRAMING_AUTO:
+                    msg = "AUTO";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE: {
+            switch (value) {
+                case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING_STATE: {
+            switch (value) {
+                case ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE:
+                    msg = "INACTIVE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING:
+                    msg = "FRAMING";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED:
+                    msg = "CONVERGED";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE: {
+            switch (value) {
+                case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE:
+                    msg = "INACTIVE";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE:
+                    msg = "ACTIVE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_METHOD: {
+            switch (value) {
+                case ANDROID_CONTROL_ZOOM_METHOD_AUTO:
+                    msg = "AUTO";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO:
+                    msg = "ZOOM_RATIO";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AE_PRIORITY_MODE: {
+            switch (value) {
+                case ANDROID_CONTROL_AE_PRIORITY_MODE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY:
+                    msg = "SENSOR_SENSITIVITY_PRIORITY";
+                    ret = 0;
+                    break;
+                case ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY:
+                    msg = "SENSOR_EXPOSURE_TIME_PRIORITY";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES: {
+            break;
+        }
 
         case ANDROID_DEMOSAIC_MODE: {
             switch (value) {
@@ -1545,6 +2151,21 @@  int camera_metadata_enum_snprint(uint32_t tag,
             }
             break;
         }
+        case ANDROID_FLASH_STRENGTH_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
 
         case ANDROID_FLASH_INFO_AVAILABLE: {
             switch (value) {
@@ -1564,6 +2185,12 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_FLASH_INFO_CHARGE_DURATION: {
             break;
         }
+        case ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
 
         case ANDROID_HOT_PIXEL_MODE: {
             switch (value) {
@@ -1705,6 +2332,14 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "GYROSCOPE";
                     ret = 0;
                     break;
+                case ANDROID_LENS_POSE_REFERENCE_UNDEFINED:
+                    msg = "UNDEFINED";
+                    ret = 0;
+                    break;
+                case ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE:
+                    msg = "AUTOMOTIVE";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1713,6 +2348,12 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_LENS_DISTORTION: {
             break;
         }
+        case ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION: {
+            break;
+        }
 
         case ANDROID_LENS_INFO_AVAILABLE_APERTURES: {
             break;
@@ -1931,6 +2572,38 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "MONOCHROME";
                     ret = 0;
                     break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA:
+                    msg = "SECURE_IMAGE_DATA";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA:
+                    msg = "SYSTEM_CAMERA";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING:
+                    msg = "OFFLINE_PROCESSING";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR:
+                    msg = "ULTRA_HIGH_RESOLUTION_SENSOR";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING:
+                    msg = "REMOSAIC_REPROCESSING";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT:
+                    msg = "DYNAMIC_RANGE_TEN_BIT";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE:
+                    msg = "STREAM_USE_CASE";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES:
+                    msg = "COLOR_SPACE_PROFILES";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1951,6 +2624,146 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS: {
             break;
         }
+        case ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP: {
+            switch (value) {
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD:
+                    msg = "STANDARD";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10:
+                    msg = "HLG10";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10:
+                    msg = "HDR10";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS:
+                    msg = "HDR10_PLUS";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF:
+                    msg = "DOLBY_VISION_10B_HDR_REF";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO:
+                    msg = "DOLBY_VISION_10B_HDR_REF_PO";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM:
+                    msg = "DOLBY_VISION_10B_HDR_OEM";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO:
+                    msg = "DOLBY_VISION_10B_HDR_OEM_PO";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF:
+                    msg = "DOLBY_VISION_8B_HDR_REF";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO:
+                    msg = "DOLBY_VISION_8B_HDR_REF_PO";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM:
+                    msg = "DOLBY_VISION_8B_HDR_OEM";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO:
+                    msg = "DOLBY_VISION_8B_HDR_OEM_PO";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX:
+                    msg = "MAX";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50:
+                    msg = "STANDARD_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50:
+                    msg = "HLG10_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50:
+                    msg = "HDR10_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50:
+                    msg = "HDR10_PLUS_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50:
+                    msg = "DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312:
+                    msg = "MAX_312";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP: {
+            switch (value) {
+                case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED:
+                    msg = "UNSPECIFIED";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB:
+                    msg = "SRGB";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3:
+                    msg = "DISPLAY_P3";
+                    ret = 0;
+                    break;
+                case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG:
+                    msg = "BT2020_HLG";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
 
         case ANDROID_SCALER_CROP_REGION: {
             break;
@@ -1985,6 +2798,22 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "BLOB";
                     ret = 0;
                     break;
+                case ANDROID_SCALER_AVAILABLE_FORMATS_RAW10:
+                    msg = "RAW10";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_FORMATS_RAW12:
+                    msg = "RAW12";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_FORMATS_RAW14:
+                    msg = "RAW14";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_FORMATS_Y8:
+                    msg = "Y8";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -2050,6 +2879,207 @@  int camera_metadata_enum_snprint(uint32_t tag,
             }
             break;
         }
+        case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW:
+                    msg = "PREVIEW";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD:
+                    msg = "RECORD";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT:
+                    msg = "VIDEO_SNAPSHOT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT:
+                    msg = "SNAPSHOT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL:
+                    msg = "ZSL";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW:
+                    msg = "RAW";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT:
+                    msg = "LOW_LATENCY_SNAPSHOT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END:
+                    msg = "PUBLIC_END";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT:
+                    msg = "10BIT_OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8:
+                    msg = "PUBLIC_END_3_8";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START:
+                    msg = "VENDOR_START";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES: {
+            break;
+        }
+        case ANDROID_SCALER_ROTATE_AND_CROP: {
+            switch (value) {
+                case ANDROID_SCALER_ROTATE_AND_CROP_NONE:
+                    msg = "NONE";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_ROTATE_AND_CROP_90:
+                    msg = "90";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_ROTATE_AND_CROP_180:
+                    msg = "180";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_ROTATE_AND_CROP_270:
+                    msg = "270";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_ROTATE_AND_CROP_AUTO:
+                    msg = "AUTO";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE: {
+            break;
+        }
+        case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED: {
+            switch (value) {
+                case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_CROP_REGION_SET: {
+            switch (value) {
+                case ANDROID_SCALER_CROP_REGION_SET_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_CROP_REGION_SET_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES: {
+            switch (value) {
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT:
+                    msg = "DEFAULT";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW:
+                    msg = "PREVIEW";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE:
+                    msg = "STILL_CAPTURE";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD:
+                    msg = "VIDEO_RECORD";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL:
+                    msg = "PREVIEW_VIDEO_STILL";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL:
+                    msg = "VIDEO_CALL";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW:
+                    msg = "CROPPED_RAW";
+                    ret = 0;
+                    break;
+                case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START:
+                    msg = "VENDOR_START";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SCALER_RAW_CROP_REGION: {
+            break;
+        }
+        case ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS: {
+            break;
+        }
 
         case ANDROID_SENSOR_EXPOSURE_TIME: {
             break;
@@ -2225,6 +3255,10 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "PN9";
                     ret = 0;
                     break;
+                case ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK:
+                    msg = "BLACK";
+                    ret = 0;
+                    break;
                 case ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1:
                     msg = "CUSTOM1";
                     ret = 0;
@@ -2252,16 +3286,64 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_SENSOR_OPAQUE_RAW_SIZE: {
             break;
         }
-
-        case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {
-            break;
-        }
-        case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {
+        case ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION: {
             break;
         }
-        case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {
+        case ANDROID_SENSOR_PIXEL_MODE: {
             switch (value) {
-                case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB:
+                case ANDROID_SENSOR_PIXEL_MODE_DEFAULT:
+                    msg = "DEFAULT";
+                    ret = 0;
+                    break;
+                case ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION:
+                    msg = "MAXIMUM_RESOLUTION";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED: {
+            switch (value) {
+                case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SENSOR_READOUT_TIMESTAMP: {
+            switch (value) {
+                case ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED:
+                    msg = "NOT_SUPPORTED";
+                    ret = 0;
+                    break;
+                case ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE:
+                    msg = "HARDWARE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
+        case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {
+            switch (value) {
+                case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB:
                     msg = "RGGB";
                     ret = 0;
                     break;
@@ -2281,6 +3363,14 @@  int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "RGB";
                     ret = 0;
                     break;
+                case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO:
+                    msg = "MONO";
+                    ret = 0;
+                    break;
+                case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR:
+                    msg = "NIR";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -2334,6 +3424,18 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: {
             break;
         }
+        case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_BINNING_FACTOR: {
+            break;
+        }
 
         case ANDROID_SHADING_MODE: {
             switch (value) {
@@ -2516,6 +3618,12 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_STATISTICS_OIS_Y_SHIFTS: {
             break;
         }
+        case ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES: {
+            break;
+        }
 
         case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {
             break;
@@ -2663,6 +3771,69 @@  int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_INFO_VERSION: {
             break;
         }
+        case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION: {
+            switch (value) {
+                case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5:
+                    msg = "HIDL_DEVICE_3_5";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE:
+                    msg = "SESSION_CONFIGURABLE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_INFO_DEVICE_STATE_ORIENTATIONS: {
+            break;
+        }
+        case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION: {
+            switch (value) {
+                case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE:
+                    msg = "UPSIDE_DOWN_CAKE";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM:
+                    msg = "VANILLA_ICE_CREAM";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA:
+                    msg = "BAKLAVA";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_INFO_DEVICE_ID: {
+            break;
+        }
+        case ANDROID_INFO_DEVICE_TYPE: {
+            switch (value) {
+                case ANDROID_INFO_DEVICE_TYPE_BUILT_IN:
+                    msg = "BUILT_IN";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_DEVICE_TYPE_EXTERNAL:
+                    msg = "EXTERNAL";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_DEVICE_TYPE_VIRTUAL:
+                    msg = "VIRTUAL";
+                    ret = 0;
+                    break;
+                case ANDROID_INFO_DEVICE_TYPE_UNKNOWN:
+                    msg = "UNKNOWN";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
 
         case ANDROID_BLACK_LEVEL_LOCK: {
             switch (value) {
@@ -2757,6 +3928,72 @@  int camera_metadata_enum_snprint(uint32_t tag,
             }
             break;
         }
+        case ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
 
         case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {
             break;
@@ -2776,6 +4013,27 @@  int camera_metadata_enum_snprint(uint32_t tag,
             }
             break;
         }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID: {
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION: {
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS: {
+            switch (value) {
+                case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
 
         case ANDROID_DISTORTION_CORRECTION_MODE: {
             switch (value) {
@@ -2800,13 +4058,4211 @@  int camera_metadata_enum_snprint(uint32_t tag,
             break;
         }
 
-    }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
 
-    strncpy(dst, msg, size - 1);
-    dst[size - 1] = '\0';
+        case ANDROID_HEIC_INFO_SUPPORTED: {
+            switch (value) {
+                case ANDROID_HEIC_INFO_SUPPORTED_FALSE:
+                    msg = "FALSE";
+                    ret = 0;
+                    break;
+                case ANDROID_HEIC_INFO_SUPPORTED_TRUE:
+                    msg = "TRUE";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT: {
+            break;
+        }
+
+        case ANDROID_AUTOMOTIVE_LOCATION: {
+            switch (value) {
+                case ANDROID_AUTOMOTIVE_LOCATION_INTERIOR:
+                    msg = "INTERIOR";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER:
+                    msg = "EXTERIOR_OTHER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT:
+                    msg = "EXTERIOR_FRONT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR:
+                    msg = "EXTERIOR_REAR";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT:
+                    msg = "EXTERIOR_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT:
+                    msg = "EXTERIOR_RIGHT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER:
+                    msg = "EXTRA_OTHER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT:
+                    msg = "EXTRA_FRONT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR:
+                    msg = "EXTRA_REAR";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT:
+                    msg = "EXTRA_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT:
+                    msg = "EXTRA_RIGHT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
+        case ANDROID_AUTOMOTIVE_LENS_FACING: {
+            switch (value) {
+                case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER:
+                    msg = "EXTERIOR_OTHER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT:
+                    msg = "EXTERIOR_FRONT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR:
+                    msg = "EXTERIOR_REAR";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT:
+                    msg = "EXTERIOR_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT:
+                    msg = "EXTERIOR_RIGHT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER:
+                    msg = "INTERIOR_OTHER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT:
+                    msg = "INTERIOR_SEAT_ROW_1_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER:
+                    msg = "INTERIOR_SEAT_ROW_1_CENTER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT:
+                    msg = "INTERIOR_SEAT_ROW_1_RIGHT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT:
+                    msg = "INTERIOR_SEAT_ROW_2_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER:
+                    msg = "INTERIOR_SEAT_ROW_2_CENTER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT:
+                    msg = "INTERIOR_SEAT_ROW_2_RIGHT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT:
+                    msg = "INTERIOR_SEAT_ROW_3_LEFT";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER:
+                    msg = "INTERIOR_SEAT_ROW_3_CENTER";
+                    ret = 0;
+                    break;
+                case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT:
+                    msg = "INTERIOR_SEAT_ROW_3_RIGHT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
+        case ANDROID_EXTENSION_STRENGTH: {
+            break;
+        }
+        case ANDROID_EXTENSION_CURRENT_TYPE: {
+            break;
+        }
+        case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR: {
+            switch (value) {
+                case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN:
+                    msg = "UNKNOWN";
+                    ret = 0;
+                    break;
+                case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS: {
+            switch (value) {
+                case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            switch (value) {
+                case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:
+                    msg = "OUTPUT";
+                    ret = 0;
+                    break;
+                case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:
+                    msg = "INPUT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+
+        case ANDROID_SHARED_SESSION_COLOR_SPACE: {
+            switch (value) {
+                case ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED:
+                    msg = "UNSPECIFIED";
+                    ret = 0;
+                    break;
+                case ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB:
+                    msg = "SRGB";
+                    ret = 0;
+                    break;
+                case ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3:
+                    msg = "DISPLAY_P3";
+                    ret = 0;
+                    break;
+                case ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG:
+                    msg = "BT2020_HLG";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS: {
+            break;
+        }
+
+        case ANDROID_DESKTOP_EFFECTS_CAPABILITIES: {
+            switch (value) {
+                case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR:
+                    msg = "BACKGROUND_BLUR";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH:
+                    msg = "FACE_RETOUCH";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT:
+                    msg = "PORTRAIT_RELIGHT";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES: {
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE: {
+            switch (value) {
+                case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT:
+                    msg = "LIGHT";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL:
+                    msg = "FULL";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE: {
+            switch (value) {
+                case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH: {
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE: {
+            switch (value) {
+                case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
+    }
+
+    strncpy(dst, msg, size - 1);
+    dst[size - 1] = '\0';
+
+    return ret;
+}
+
+int camera_metadata_enum_value(uint32_t tag,
+                                 const char *name,
+                                 size_t size,
+                                 uint32_t *value) {
+    if ((name == NULL) || (value == NULL)) {
+        return -1;
+    }
+
+    const char *enumName = NULL;
+    int ret = -1;
+
+    switch(tag) {
+        case ANDROID_COLOR_CORRECTION_MODE: {
+                enumName = "TRANSFORM_MATRIX";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CCT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_MODE_CCT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_TRANSFORM: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_GAINS: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_ABERRATION_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_COLOR_TINT: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE: {
+            break;
+        }
+        case ANDROID_COLOR_CORRECTION_AVAILABLE_MODES: {
+            break;
+        }
+
+        case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "50HZ";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ;
+                    ret = 0;
+                    break;
+                }
+                enumName = "60HZ";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_LOCK: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_LOCK_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_LOCK_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON_AUTO_FLASH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON_ALWAYS_FLASH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON_AUTO_FLASH_REDEYE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON_EXTERNAL_FLASH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON_EXTERNAL_FLASH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_REGIONS: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_TARGET_FPS_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER: {
+                enumName = "IDLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CANCEL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AF_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_AUTO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MACRO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_MACRO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONTINUOUS_VIDEO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONTINUOUS_PICTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EDOF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_MODE_EDOF;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AF_REGIONS: {
+            break;
+        }
+        case ANDROID_CONTROL_AF_TRIGGER: {
+                enumName = "IDLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_TRIGGER_IDLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_TRIGGER_START;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CANCEL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_TRIGGER_CANCEL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_LOCK: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_LOCK_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_LOCK_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_AUTO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INCANDESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_INCANDESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "WARM_FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DAYLIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_DAYLIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CLOUDY_DAYLIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TWILIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_TWILIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SHADE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_MODE_SHADE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_REGIONS: {
+            break;
+        }
+        case ANDROID_CONTROL_CAPTURE_INTENT: {
+                enumName = "CUSTOM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PREVIEW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STILL_CAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIDEO_RECORD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIDEO_SNAPSHOT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZERO_SHUTTER_LAG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MANUAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MOTION_TRACKING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_CAPTURE_INTENT_MOTION_TRACKING;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_EFFECT_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MONO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_MONO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "NEGATIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_NEGATIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SOLARIZE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_SOLARIZE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SEPIA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_SEPIA;
+                    ret = 0;
+                    break;
+                }
+                enumName = "POSTERIZE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_POSTERIZE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "WHITEBOARD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BLACKBOARD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AQUA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EFFECT_MODE_AQUA;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_MODE_AUTO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "USE_SCENE_MODE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_MODE_USE_SCENE_MODE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "OFF_KEEP_STATE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_MODE_OFF_KEEP_STATE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "USE_EXTENDED_SCENE_MODE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_SCENE_MODE: {
+                enumName = "DISABLED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_DISABLED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FACE_PRIORITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ACTION";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_ACTION;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PORTRAIT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_PORTRAIT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LANDSCAPE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_LANDSCAPE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "NIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_NIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "NIGHT_PORTRAIT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "THEATRE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_THEATRE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BEACH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_BEACH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SNOW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_SNOW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SUNSET";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_SUNSET;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STEADYPHOTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FIREWORKS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_FIREWORKS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SPORTS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_SPORTS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PARTY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_PARTY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CANDLELIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BARCODE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_BARCODE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_SPEED_VIDEO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HDR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_HDR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FACE_PRIORITY_LOW_LIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY_LOW_LIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DEVICE_CUSTOM_START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_DEVICE_CUSTOM_START;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DEVICE_CUSTOM_END";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SCENE_MODE_DEVICE_CUSTOM_END;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PREVIEW_STABILIZATION";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_AVAILABLE_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_COMPENSATION_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_COMPENSATION_STEP: {
+            break;
+        }
+        case ANDROID_CONTROL_AF_AVAILABLE_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_EFFECTS: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_SCENE_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_AWB_AVAILABLE_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_MAX_REGIONS: {
+            break;
+        }
+        case ANDROID_CONTROL_SCENE_MODE_OVERRIDES: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_PRECAPTURE_ID: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_STATE: {
+                enumName = "INACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_INACTIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SEARCHING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_SEARCHING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONVERGED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_CONVERGED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LOCKED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_LOCKED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FLASH_REQUIRED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PRECAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_STATE_PRECAPTURE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AF_STATE: {
+                enumName = "INACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_INACTIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PASSIVE_SCAN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PASSIVE_FOCUSED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ACTIVE_SCAN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FOCUSED_LOCKED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "NOT_FOCUSED_LOCKED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PASSIVE_UNFOCUSED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AF_TRIGGER_ID: {
+            break;
+        }
+        case ANDROID_CONTROL_AWB_STATE: {
+                enumName = "INACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_STATE_INACTIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SEARCHING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_STATE_SEARCHING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONVERGED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_STATE_CONVERGED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LOCKED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_STATE_LOCKED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS: {
+            break;
+        }
+        case ANDROID_CONTROL_AE_LOCK_AVAILABLE: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_LOCK_AVAILABLE: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_MODES: {
+            break;
+        }
+        case ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST: {
+            break;
+        }
+        case ANDROID_CONTROL_ENABLE_ZSL: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_ENABLE_ZSL_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_ENABLE_ZSL_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AF_SCENE_CHANGE: {
+                enumName = "NOT_DETECTED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_SCENE_CHANGE_NOT_DETECTED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DETECTED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_SCENE_CHANGE_DETECTED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES: {
+            break;
+        }
+        case ANDROID_CONTROL_EXTENDED_SCENE_MODE: {
+                enumName = "DISABLED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BOKEH_STILL_CAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BOKEH_CONTINUOUS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VENDOR_START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_RATIO_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_RATIO: {
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_CONTROL_AF_REGIONS_SET: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_REGIONS_SET_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AF_REGIONS_SET_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_REGIONS_SET: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_REGIONS_SET_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_REGIONS_SET_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AWB_REGIONS_SET: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_REGIONS_SET_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AWB_REGIONS_SET_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_SETTINGS_OVERRIDE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZOOM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VENDOR_START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES: {
+            break;
+        }
+        case ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER: {
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_ON;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_AUTO;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AUTOFRAMING_STATE: {
+                enumName = "INACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FRAMING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONVERGED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE: {
+            break;
+        }
+        case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE: {
+                enumName = "INACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ACTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_ZOOM_METHOD: {
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_ZOOM_METHOD_AUTO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZOOM_RATIO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_PRIORITY_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRIORITY_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SENSOR_SENSITIVITY_PRIORITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SENSOR_EXPOSURE_TIME_PRIORITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES: {
+            break;
+        }
+
+        case ANDROID_DEMOSAIC_MODE: {
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEMOSAIC_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_EDGE_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EDGE_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EDGE_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EDGE_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZERO_SHUTTER_LAG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_EDGE_STRENGTH: {
+            break;
+        }
+        case ANDROID_EDGE_AVAILABLE_EDGE_MODES: {
+            break;
+        }
+
+        case ANDROID_FLASH_FIRING_POWER: {
+            break;
+        }
+        case ANDROID_FLASH_FIRING_TIME: {
+            break;
+        }
+        case ANDROID_FLASH_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SINGLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_MODE_SINGLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TORCH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_MODE_TORCH;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_FLASH_COLOR_TEMPERATURE: {
+            break;
+        }
+        case ANDROID_FLASH_MAX_ENERGY: {
+            break;
+        }
+        case ANDROID_FLASH_STATE: {
+                enumName = "UNAVAILABLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_STATE_UNAVAILABLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CHARGING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_STATE_CHARGING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "READY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_STATE_READY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FIRED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_STATE_FIRED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PARTIAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_STATE_PARTIAL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_FLASH_STRENGTH_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
+
+        case ANDROID_FLASH_INFO_AVAILABLE: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_INFO_AVAILABLE_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_FLASH_INFO_AVAILABLE_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_FLASH_INFO_CHARGE_DURATION: {
+            break;
+        }
+        case ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL: {
+            break;
+        }
+        case ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL: {
+            break;
+        }
+
+        case ANDROID_HOT_PIXEL_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HOT_PIXEL_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HOT_PIXEL_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES: {
+            break;
+        }
+
+        case ANDROID_JPEG_GPS_COORDINATES: {
+            break;
+        }
+        case ANDROID_JPEG_GPS_PROCESSING_METHOD: {
+            break;
+        }
+        case ANDROID_JPEG_GPS_TIMESTAMP: {
+            break;
+        }
+        case ANDROID_JPEG_ORIENTATION: {
+            break;
+        }
+        case ANDROID_JPEG_QUALITY: {
+            break;
+        }
+        case ANDROID_JPEG_THUMBNAIL_QUALITY: {
+            break;
+        }
+        case ANDROID_JPEG_THUMBNAIL_SIZE: {
+            break;
+        }
+        case ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES: {
+            break;
+        }
+        case ANDROID_JPEG_MAX_SIZE: {
+            break;
+        }
+        case ANDROID_JPEG_SIZE: {
+            break;
+        }
+
+        case ANDROID_LENS_APERTURE: {
+            break;
+        }
+        case ANDROID_LENS_FILTER_DENSITY: {
+            break;
+        }
+        case ANDROID_LENS_FOCAL_LENGTH: {
+            break;
+        }
+        case ANDROID_LENS_FOCUS_DISTANCE: {
+            break;
+        }
+        case ANDROID_LENS_OPTICAL_STABILIZATION_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LENS_FACING: {
+                enumName = "FRONT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_FACING_FRONT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BACK";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_FACING_BACK;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERNAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_FACING_EXTERNAL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LENS_POSE_ROTATION: {
+            break;
+        }
+        case ANDROID_LENS_POSE_TRANSLATION: {
+            break;
+        }
+        case ANDROID_LENS_FOCUS_RANGE: {
+            break;
+        }
+        case ANDROID_LENS_STATE: {
+                enumName = "STATIONARY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_STATE_STATIONARY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MOVING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_STATE_MOVING;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LENS_INTRINSIC_CALIBRATION: {
+            break;
+        }
+        case ANDROID_LENS_RADIAL_DISTORTION: {
+            break;
+        }
+        case ANDROID_LENS_POSE_REFERENCE: {
+                enumName = "PRIMARY_CAMERA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_POSE_REFERENCE_PRIMARY_CAMERA;
+                    ret = 0;
+                    break;
+                }
+                enumName = "GYROSCOPE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_POSE_REFERENCE_GYROSCOPE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "UNDEFINED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_POSE_REFERENCE_UNDEFINED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTOMOTIVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LENS_DISTORTION: {
+            break;
+        }
+        case ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION: {
+            break;
+        }
+
+        case ANDROID_LENS_INFO_AVAILABLE_APERTURES: {
+            break;
+        }
+        case ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES: {
+            break;
+        }
+        case ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS: {
+            break;
+        }
+        case ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION: {
+            break;
+        }
+        case ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE: {
+            break;
+        }
+        case ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE: {
+            break;
+        }
+        case ANDROID_LENS_INFO_SHADING_MAP_SIZE: {
+            break;
+        }
+        case ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION: {
+                enumName = "UNCALIBRATED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "APPROXIMATE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CALIBRATED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_NOISE_REDUCTION_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_NOISE_REDUCTION_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_NOISE_REDUCTION_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MINIMAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_NOISE_REDUCTION_MODE_MINIMAL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZERO_SHUTTER_LAG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_NOISE_REDUCTION_STRENGTH: {
+            break;
+        }
+        case ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES: {
+            break;
+        }
+
+        case ANDROID_QUIRKS_METERING_CROP_REGION: {
+            break;
+        }
+        case ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO: {
+            break;
+        }
+        case ANDROID_QUIRKS_USE_ZSL_FORMAT: {
+            break;
+        }
+        case ANDROID_QUIRKS_USE_PARTIAL_RESULT: {
+            break;
+        }
+        case ANDROID_QUIRKS_PARTIAL_RESULT: {
+                enumName = "FINAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_QUIRKS_PARTIAL_RESULT_FINAL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PARTIAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_REQUEST_FRAME_COUNT: {
+            break;
+        }
+        case ANDROID_REQUEST_ID: {
+            break;
+        }
+        case ANDROID_REQUEST_INPUT_STREAMS: {
+            break;
+        }
+        case ANDROID_REQUEST_METADATA_MODE: {
+                enumName = "NONE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_METADATA_MODE_NONE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FULL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_METADATA_MODE_FULL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_REQUEST_OUTPUT_STREAMS: {
+            break;
+        }
+        case ANDROID_REQUEST_TYPE: {
+                enumName = "CAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_TYPE_CAPTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "REPROCESS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_TYPE_REPROCESS;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS: {
+            break;
+        }
+        case ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS: {
+            break;
+        }
+        case ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS: {
+            break;
+        }
+        case ANDROID_REQUEST_PIPELINE_DEPTH: {
+            break;
+        }
+        case ANDROID_REQUEST_PIPELINE_MAX_DEPTH: {
+            break;
+        }
+        case ANDROID_REQUEST_PARTIAL_RESULT_COUNT: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_CAPABILITIES: {
+                enumName = "BACKWARD_COMPATIBLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MANUAL_SENSOR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MANUAL_POST_PROCESSING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PRIVATE_REPROCESSING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "READ_SENSOR_SETTINGS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BURST_CAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "YUV_REPROCESSING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DEPTH_OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CONSTRAINED_HIGH_SPEED_VIDEO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MOTION_TRACKING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LOGICAL_MULTI_CAMERA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MONOCHROME";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SECURE_IMAGE_DATA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SYSTEM_CAMERA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA;
+                    ret = 0;
+                    break;
+                }
+                enumName = "OFFLINE_PROCESSING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ULTRA_HIGH_RESOLUTION_SENSOR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "REMOSAIC_REPROCESSING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DYNAMIC_RANGE_TEN_BIT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STREAM_USE_CASE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "COLOR_SPACE_PROFILES";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_RESULT_KEYS: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_SESSION_KEYS: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS: {
+            break;
+        }
+        case ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP: {
+                enumName = "STANDARD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HLG10";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HDR10";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HDR10_PLUS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_REF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_REF_PO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_OEM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_OEM_PO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_REF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_REF_PO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_OEM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_OEM_PO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MAX";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STANDARD_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HLG10_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HDR10_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HDR10_PLUS_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MAX_312";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE: {
+            break;
+        }
+        case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP: {
+                enumName = "UNSPECIFIED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SRGB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DISPLAY_P3";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BT2020_HLG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_SCALER_CROP_REGION: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_FORMATS: {
+                enumName = "RAW16";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW16;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW_OPAQUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "YV12";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_YV12;
+                    ret = 0;
+                    break;
+                }
+                enumName = "YCrCb_420_SP";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_YCrCb_420_SP;
+                    ret = 0;
+                    break;
+                }
+                enumName = "IMPLEMENTATION_DEFINED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "YCbCr_420_888";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BLOB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_BLOB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW10";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW10;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW12";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW12;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW14";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW14;
+                    ret = 0;
+                    break;
+                }
+                enumName = "Y8";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_FORMATS_Y8;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_JPEG_SIZES: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_RAW_SIZES: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_SCALER_CROPPING_TYPE: {
+                enumName = "CENTER_ONLY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FREEFORM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_CROPPING_TYPE_FREEFORM;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS: {
+                enumName = "PREVIEW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RECORD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIDEO_SNAPSHOT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SNAPSHOT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ZSL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RAW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LOW_LATENCY_SNAPSHOT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PUBLIC_END";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END;
+                    ret = 0;
+                    break;
+                }
+                enumName = "10BIT_OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PUBLIC_END_3_8";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VENDOR_START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES: {
+            break;
+        }
+        case ANDROID_SCALER_ROTATE_AND_CROP: {
+                enumName = "NONE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "90";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_ROTATE_AND_CROP_90;
+                    ret = 0;
+                    break;
+                }
+                enumName = "180";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_ROTATE_AND_CROP_180;
+                    ret = 0;
+                    break;
+                }
+                enumName = "270";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_ROTATE_AND_CROP_270;
+                    ret = 0;
+                    break;
+                }
+                enumName = "AUTO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE: {
+            break;
+        }
+        case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_CROP_REGION_SET: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_CROP_REGION_SET_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_CROP_REGION_SET_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES: {
+                enumName = "DEFAULT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PREVIEW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STILL_CAPTURE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIDEO_RECORD";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PREVIEW_VIDEO_STILL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIDEO_CALL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CROPPED_RAW";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VENDOR_START";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SCALER_RAW_CROP_REGION: {
+            break;
+        }
+        case ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS: {
+            break;
+        }
+
+        case ANDROID_SENSOR_EXPOSURE_TIME: {
+            break;
+        }
+        case ANDROID_SENSOR_FRAME_DURATION: {
+            break;
+        }
+        case ANDROID_SENSOR_SENSITIVITY: {
+            break;
+        }
+        case ANDROID_SENSOR_REFERENCE_ILLUMINANT1: {
+                enumName = "DAYLIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TUNGSTEN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FLASH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLASH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FINE_WEATHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CLOUDY_WEATHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SHADE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_SHADE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DAYLIGHT_FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DAY_WHITE_FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "COOL_WHITE_FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "WHITE_FLUORESCENT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STANDARD_A";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STANDARD_B";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B;
+                    ret = 0;
+                    break;
+                }
+                enumName = "STANDARD_C";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C;
+                    ret = 0;
+                    break;
+                }
+                enumName = "D55";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D55;
+                    ret = 0;
+                    break;
+                }
+                enumName = "D65";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D65;
+                    ret = 0;
+                    break;
+                }
+                enumName = "D75";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D75;
+                    ret = 0;
+                    break;
+                }
+                enumName = "D50";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D50;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ISO_STUDIO_TUNGSTEN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_REFERENCE_ILLUMINANT2: {
+            break;
+        }
+        case ANDROID_SENSOR_CALIBRATION_TRANSFORM1: {
+            break;
+        }
+        case ANDROID_SENSOR_CALIBRATION_TRANSFORM2: {
+            break;
+        }
+        case ANDROID_SENSOR_COLOR_TRANSFORM1: {
+            break;
+        }
+        case ANDROID_SENSOR_COLOR_TRANSFORM2: {
+            break;
+        }
+        case ANDROID_SENSOR_FORWARD_MATRIX1: {
+            break;
+        }
+        case ANDROID_SENSOR_FORWARD_MATRIX2: {
+            break;
+        }
+        case ANDROID_SENSOR_BASE_GAIN_FACTOR: {
+            break;
+        }
+        case ANDROID_SENSOR_BLACK_LEVEL_PATTERN: {
+            break;
+        }
+        case ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY: {
+            break;
+        }
+        case ANDROID_SENSOR_ORIENTATION: {
+            break;
+        }
+        case ANDROID_SENSOR_PROFILE_HUE_SAT_MAP_DIMENSIONS: {
+            break;
+        }
+        case ANDROID_SENSOR_TIMESTAMP: {
+            break;
+        }
+        case ANDROID_SENSOR_TEMPERATURE: {
+            break;
+        }
+        case ANDROID_SENSOR_NEUTRAL_COLOR_POINT: {
+            break;
+        }
+        case ANDROID_SENSOR_NOISE_PROFILE: {
+            break;
+        }
+        case ANDROID_SENSOR_PROFILE_HUE_SAT_MAP: {
+            break;
+        }
+        case ANDROID_SENSOR_PROFILE_TONE_CURVE: {
+            break;
+        }
+        case ANDROID_SENSOR_GREEN_SPLIT: {
+            break;
+        }
+        case ANDROID_SENSOR_TEST_PATTERN_DATA: {
+            break;
+        }
+        case ANDROID_SENSOR_TEST_PATTERN_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SOLID_COLOR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "COLOR_BARS";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS;
+                    ret = 0;
+                    break;
+                }
+                enumName = "COLOR_BARS_FADE_TO_GRAY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PN9";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_PN9;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BLACK";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CUSTOM1";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES: {
+            break;
+        }
+        case ANDROID_SENSOR_ROLLING_SHUTTER_SKEW: {
+            break;
+        }
+        case ANDROID_SENSOR_OPTICAL_BLACK_REGIONS: {
+            break;
+        }
+        case ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL: {
+            break;
+        }
+        case ANDROID_SENSOR_DYNAMIC_WHITE_LEVEL: {
+            break;
+        }
+        case ANDROID_SENSOR_OPAQUE_RAW_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_PIXEL_MODE: {
+                enumName = "DEFAULT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_PIXEL_MODE_DEFAULT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MAXIMUM_RESOLUTION";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED: {
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_READOUT_TIMESTAMP: {
+                enumName = "NOT_SUPPORTED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HARDWARE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {
+                enumName = "RGGB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "GRBG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG;
+                    ret = 0;
+                    break;
+                }
+                enumName = "GBRG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BGGR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "RGB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "MONO";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
+                    ret = 0;
+                    break;
+                }
+                enumName = "NIR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_MAX_FRAME_DURATION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PHYSICAL_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_WHITE_LEVEL: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE: {
+                enumName = "UNKNOWN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "REALTIME";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_SENSOR_INFO_BINNING_FACTOR: {
+            break;
+        }
+
+        case ANDROID_SHADING_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHADING_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHADING_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHADING_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SHADING_STRENGTH: {
+            break;
+        }
+        case ANDROID_SHADING_AVAILABLE_MODES: {
+            break;
+        }
+
+        case ANDROID_STATISTICS_FACE_DETECT_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SIMPLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FULL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_HISTOGRAM_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_HISTOGRAM_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_SHARPNESS_MAP_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_FACE_IDS: {
+            break;
+        }
+        case ANDROID_STATISTICS_FACE_LANDMARKS: {
+            break;
+        }
+        case ANDROID_STATISTICS_FACE_RECTANGLES: {
+            break;
+        }
+        case ANDROID_STATISTICS_FACE_SCORES: {
+            break;
+        }
+        case ANDROID_STATISTICS_HISTOGRAM: {
+            break;
+        }
+        case ANDROID_STATISTICS_SHARPNESS_MAP: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_SHADING_CORRECTION_MAP: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_SHADING_MAP: {
+            break;
+        }
+        case ANDROID_STATISTICS_PREDICTED_COLOR_GAINS: {
+            break;
+        }
+        case ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM: {
+            break;
+        }
+        case ANDROID_STATISTICS_SCENE_FLICKER: {
+                enumName = "NONE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_SCENE_FLICKER_NONE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "50HZ";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_SCENE_FLICKER_50HZ;
+                    ret = 0;
+                    break;
+                }
+                enumName = "60HZ";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_SCENE_FLICKER_60HZ;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_HOT_PIXEL_MAP: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_SHADING_MAP_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_OIS_DATA_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_OIS_DATA_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_STATISTICS_OIS_DATA_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_STATISTICS_OIS_TIMESTAMPS: {
+            break;
+        }
+        case ANDROID_STATISTICS_OIS_X_SHIFTS: {
+            break;
+        }
+        case ANDROID_STATISTICS_OIS_Y_SHIFTS: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS: {
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES: {
+            break;
+        }
+
+        case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_MAX_FACE_COUNT: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES: {
+            break;
+        }
+        case ANDROID_STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES: {
+            break;
+        }
+
+        case ANDROID_TONEMAP_CURVE_BLUE: {
+            break;
+        }
+        case ANDROID_TONEMAP_CURVE_GREEN: {
+            break;
+        }
+        case ANDROID_TONEMAP_CURVE_RED: {
+            break;
+        }
+        case ANDROID_TONEMAP_MODE: {
+                enumName = "CONTRAST_CURVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_MODE_CONTRAST_CURVE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "GAMMA_VALUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_MODE_GAMMA_VALUE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PRESET_CURVE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_MODE_PRESET_CURVE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_TONEMAP_MAX_CURVE_POINTS: {
+            break;
+        }
+        case ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES: {
+            break;
+        }
+        case ANDROID_TONEMAP_GAMMA: {
+            break;
+        }
+        case ANDROID_TONEMAP_PRESET_CURVE: {
+                enumName = "SRGB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_PRESET_CURVE_SRGB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "REC709";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_TONEMAP_PRESET_CURVE_REC709;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_LED_TRANSMIT: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LED_TRANSMIT_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LED_TRANSMIT_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LED_AVAILABLE_LEDS: {
+                enumName = "TRANSMIT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LED_AVAILABLE_LEDS_TRANSMIT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL: {
+                enumName = "LIMITED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FULL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LEGACY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;
+                    ret = 0;
+                    break;
+                }
+                enumName = "3";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERNAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_INFO_VERSION: {
+            break;
+        }
+        case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION: {
+                enumName = "HIDL_DEVICE_3_5";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SESSION_CONFIGURABLE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_INFO_DEVICE_STATE_ORIENTATIONS: {
+            break;
+        }
+        case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION: {
+                enumName = "UPSIDE_DOWN_CAKE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VANILLA_ICE_CREAM";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BAKLAVA";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_INFO_DEVICE_ID: {
+            break;
+        }
+        case ANDROID_INFO_DEVICE_TYPE: {
+                enumName = "BUILT_IN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_DEVICE_TYPE_BUILT_IN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERNAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_DEVICE_TYPE_EXTERNAL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "VIRTUAL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_DEVICE_TYPE_VIRTUAL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "UNKNOWN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_INFO_DEVICE_TYPE_UNKNOWN;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_BLACK_LEVEL_LOCK: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_BLACK_LEVEL_LOCK_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_BLACK_LEVEL_LOCK_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_SYNC_FRAME_NUMBER: {
+                enumName = "CONVERGING";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SYNC_FRAME_NUMBER_CONVERGING;
+                    ret = 0;
+                    break;
+                }
+                enumName = "UNKNOWN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SYNC_FRAME_NUMBER_UNKNOWN;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SYNC_MAX_LATENCY: {
+                enumName = "PER_FRAME_CONTROL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;
+                    ret = 0;
+                    break;
+                }
+                enumName = "UNKNOWN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR: {
+            break;
+        }
+        case ANDROID_REPROCESS_MAX_CAPTURE_STALL: {
+            break;
+        }
+
+        case ANDROID_DEPTH_MAX_DEPTH_SAMPLES: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+
+        case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE: {
+                enumName = "APPROXIMATE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "CALIBRATED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID: {
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION: {
+            break;
+        }
+        case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_DISTORTION_CORRECTION_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DISTORTION_CORRECTION_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FAST";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DISTORTION_CORRECTION_MODE_FAST;
+                    ret = 0;
+                    break;
+                }
+                enumName = "HIGH_QUALITY";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DISTORTION_CORRECTION_MODE_HIGH_QUALITY;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES: {
+            break;
+        }
+
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+
+        case ANDROID_HEIC_INFO_SUPPORTED: {
+                enumName = "FALSE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_INFO_SUPPORTED_FALSE;
+                    ret = 0;
+                    break;
+                }
+                enumName = "TRUE";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_HEIC_INFO_SUPPORTED_TRUE;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT: {
+            break;
+        }
+
+        case ANDROID_AUTOMOTIVE_LOCATION: {
+                enumName = "INTERIOR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_INTERIOR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_OTHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_FRONT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_REAR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTRA_OTHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTRA_FRONT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTRA_REAR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTRA_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTRA_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_AUTOMOTIVE_LENS_FACING: {
+                enumName = "EXTERIOR_OTHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_FRONT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_REAR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "EXTERIOR_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_OTHER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_1_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_1_CENTER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_1_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_2_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_2_CENTER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_2_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_3_LEFT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_3_CENTER";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INTERIOR_SEAT_ROW_3_RIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_EXTENSION_STRENGTH: {
+            break;
+        }
+        case ANDROID_EXTENSION_CURRENT_TYPE: {
+            break;
+        }
+        case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR: {
+                enumName = "UNKNOWN";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN;
+                    ret = 0;
+                    break;
+                }
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {
+                enumName = "OUTPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "INPUT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+        case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION: {
+            break;
+        }
+
+        case ANDROID_SHARED_SESSION_COLOR_SPACE: {
+                enumName = "UNSPECIFIED";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED;
+                    ret = 0;
+                    break;
+                }
+                enumName = "SRGB";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB;
+                    ret = 0;
+                    break;
+                }
+                enumName = "DISPLAY_P3";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3;
+                    ret = 0;
+                    break;
+                }
+                enumName = "BT2020_HLG";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS: {
+            break;
+        }
+
+        case ANDROID_DESKTOP_EFFECTS_CAPABILITIES: {
+                enumName = "BACKGROUND_BLUR";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FACE_RETOUCH";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH;
+                    ret = 0;
+                    break;
+                }
+                enumName = "PORTRAIT_RELIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES: {
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "LIGHT";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT;
+                    ret = 0;
+                    break;
+                }
+                enumName = "FULL";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH: {
+            break;
+        }
+        case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE: {
+                enumName = "OFF";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF;
+                    ret = 0;
+                    break;
+                }
+                enumName = "ON";
+                if (strncmp(name, enumName, size) == 0) {
+                    *value = ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON;
+                    ret = 0;
+                    break;
+                }
+            break;
+        }
+
+    }
 
     return ret;
 }
 
 
-#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE 29
+#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE 42