Merge tag 'android-4.4_r1' into cm-11.0

Android 4.4 Release 1.0

33 files changed, 4988 insertions, 1648 deletions

diff --git a/audio_effects/include/audio_effects/effect_loudnessenhancer.h b/audio_effects/include/audio_effects/effect_loudnessenhancer.h
new file mode 100644
index 00000000..c5bcaee8
--- /dev/null
+++ b/audio_effects/include/audio_effects/effect_loudnessenhancer.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_EFFECT_LOUDNESS_ENHANCER_H_
+#define ANDROID_EFFECT_LOUDNESS_ENHANCER_H_
+
+#include <hardware/audio_effect.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+// this effect is not defined in OpenSL ES as one of the standard effects
+static const effect_uuid_t FX_IID_LOUDNESS_ENHANCER_ =
+        {0xfe3199be, 0xaed0, 0x413f, 0x87bb, {0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}};
+const effect_uuid_t * const FX_IID_LOUDNESS_ENHANCER = &FX_IID_LOUDNESS_ENHANCER_;
+
+#define LOUDNESS_ENHANCER_DEFAULT_TARGET_GAIN_MB 0 // mB
+
+// enumerated parameters for DRC effect
+// to keep in sync with frameworks/base/media/java/android/media/audiofx/LoudnessEnhancer.java
+typedef enum
+{
+    LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB = 0,// target gain expressed in mB
+} t_level_monitor_params;
+
+#if __cplusplus
+}  // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECT_LOUDNESS_ENHANCER_H_*/
diff --git a/audio_effects/include/audio_effects/effect_visualizer.h b/audio_effects/include/audio_effects/effect_visualizer.h
index 7c74f35a..cfd99f50 100644
--- a/audio_effects/include/audio_effects/effect_visualizer.h
+++ b/audio_effects/include/audio_effects/effect_visualizer.h
@@ -36,24 +36,35 @@ const effect_uuid_t * const SL_IID_VISUALIZATION = &SL_IID_VISUALIZATION_;
 #define VISUALIZER_SCALING_MODE_NORMALIZED 0
 #define VISUALIZER_SCALING_MODE_AS_PLAYED  1
 
+#define MEASUREMENT_MODE_NONE      0x0
+#define MEASUREMENT_MODE_PEAK_RMS  0x1
+
+#define MEASUREMENT_IDX_PEAK 0
+#define MEASUREMENT_IDX_RMS  1
+
 /* enumerated parameters for Visualizer effect */
 typedef enum
 {
     VISUALIZER_PARAM_CAPTURE_SIZE, // Sets the number PCM samples in the capture.
     VISUALIZER_PARAM_SCALING_MODE, // Sets the way the captured data is scaled
     VISUALIZER_PARAM_LATENCY,      // Informs the visualizer about the downstream latency
+    VISUALIZER_PARAM_MEASUREMENT_MODE, // Sets which measurements are to be made
 } t_visualizer_params;
 
 /* commands */
 typedef enum
 {
     VISUALIZER_CMD_CAPTURE = EFFECT_CMD_FIRST_PROPRIETARY, // Gets the latest PCM capture.
+    VISUALIZER_CMD_MEASURE, // Gets the current measurements
 }t_visualizer_cmds;
 
 // VISUALIZER_CMD_CAPTURE retrieves the latest PCM snapshot captured by the visualizer engine.
 // It returns the number of samples specified by VISUALIZER_PARAM_CAPTURE_SIZE
 // in 8 bit unsigned format (0 = 0x80)
 
+// VISUALIZER_CMD_MEASURE retrieves the lastest measurements as int32_t saved in the
+// MEASUREMENT_IDX_* array index order.
+
 #if __cplusplus
 }  // extern "C"
 #endif
diff --git a/audio_route/audio_route.c b/audio_route/audio_route.c
index b8eddbd1..4a449079 100644
--- a/audio_route/audio_route.c
+++ b/audio_route/audio_route.c
@@ -38,22 +38,16 @@ struct mixer_state {
     int *old_value;
     int *new_value;
     int *reset_value;
-    /* If linked is true, only the first element in each array is valid */
-    bool old_linked;
-    bool new_linked;
-    bool reset_linked;
 };
 
 struct mixer_setting {
-    struct mixer_ctl *ctl;
+    unsigned int ctl_index;
     unsigned int num_values;
     int *value;
-    /* If linked is true, only the first element in each array is valid */
-    bool linked;
 };
 
 struct mixer_value {
-    struct mixer_ctl *ctl;
+    unsigned int ctl_index;
     int index;
     int value;
 };
@@ -83,16 +77,22 @@ struct config_parse_state {
 
 /* path functions */
 
-static void path_print(struct mixer_path *path)
+static inline struct mixer_ctl *index_to_ctl(struct audio_route *ar,
+                                             unsigned int ctl_index)
+{
+    return ar->mixer_state[ctl_index].ctl;
+}
+
+static void path_print(struct audio_route *ar, struct mixer_path *path)
 {
     unsigned int i;
     unsigned int j;
 
     ALOGE("Path: %s, length: %d", path->name, path->length);
     for (i = 0; i < path->length; i++) {
-        ALOGE("  id=%d: ctl=%s linked=%c", i,
-              mixer_ctl_get_name(path->setting[i].ctl),
-              path->setting[i].linked ? 'y' : 'n');
+        struct mixer_ctl *ctl = index_to_ctl(ar, path->setting[i].ctl_index);
+
+        ALOGE("  id=%d: ctl=%s", i, mixer_ctl_get_name(ctl));
         for (j = 0; j < path->setting[i].num_values; j++)
             ALOGE("    id=%d value=%d", j, path->setting[i].value[j]);
     }
@@ -162,12 +162,13 @@ static struct mixer_path *path_create(struct audio_route *ar, const char *name)
     return &ar->mixer_path[ar->num_mixer_paths++];
 }
 
-static int find_ctl_in_path(struct mixer_path *path, struct mixer_ctl *ctl)
+static int find_ctl_index_in_path(struct mixer_path *path,
+                                  unsigned int ctl_index)
 {
     unsigned int i;
 
     for (i = 0; i < path->length; i++)
-        if (path->setting[i].ctl == ctl)
+        if (path->setting[i].ctl_index == ctl_index)
             return i;
 
     return -1;
@@ -201,15 +202,16 @@ static int alloc_path_setting(struct mixer_path *path)
     return path_index;
 }
 
-static int path_add_setting(struct mixer_path *path,
+static int path_add_setting(struct audio_route *ar, struct mixer_path *path,
                             struct mixer_setting *setting)
 {
-    unsigned int i;
     int path_index;
 
-    if (find_ctl_in_path(path, setting->ctl) != -1) {
+    if (find_ctl_index_in_path(path, setting->ctl_index) != -1) {
+        struct mixer_ctl *ctl = index_to_ctl(ar, setting->ctl_index);
+
         ALOGE("Control '%s' already exists in path '%s'",
-              mixer_ctl_get_name(setting->ctl), path->name);
+              mixer_ctl_get_name(ctl), path->name);
         return -1;
     }
 
@@ -217,36 +219,34 @@ static int path_add_setting(struct mixer_path *path,
     if (path_index < 0)
         return -1;
 
-    path->setting[path_index].ctl = setting->ctl;
+    path->setting[path_index].ctl_index = setting->ctl_index;
     path->setting[path_index].num_values = setting->num_values;
     path->setting[path_index].value = malloc(setting->num_values * sizeof(int));
-    path->setting[path_index].linked = setting->linked;
-    if (setting->linked) {
-        path->setting[path_index].value[0] = setting->value[0];
-    } else {
-        for (i = 0; i < setting->num_values; i++)
-            path->setting[path_index].value[i] = setting->value[i];
-    }
+    /* copy all values */
+    memcpy(path->setting[path_index].value, setting->value,
+           setting->num_values * sizeof(int));
 
     return 0;
 }
 
-static int path_add_value(struct mixer_path *path,
+static int path_add_value(struct audio_route *ar, struct mixer_path *path,
                           struct mixer_value *mixer_value)
 {
     unsigned int i;
     int path_index;
     unsigned int num_values;
+    struct mixer_ctl *ctl;
 
     /* Check that mixer value index is within range */
-    num_values = mixer_ctl_get_num_values(mixer_value->ctl);
+    ctl = index_to_ctl(ar, mixer_value->ctl_index);
+    num_values = mixer_ctl_get_num_values(ctl);
     if (mixer_value->index >= (int)num_values) {
         ALOGE("mixer index %d is out of range for '%s'", mixer_value->index,
-              mixer_ctl_get_name(mixer_value->ctl));
+              mixer_ctl_get_name(ctl));
         return -1;
     }
 
-    path_index = find_ctl_in_path(path, mixer_value->ctl);
+    path_index = find_ctl_index_in_path(path, mixer_value->ctl_index);
     if (path_index < 0) {
         /* New path */
 
@@ -255,38 +255,31 @@ static int path_add_value(struct mixer_path *path,
             return -1;
 
         /* initialise the new path setting */
-        path->setting[path_index].ctl = mixer_value->ctl;
+        path->setting[path_index].ctl_index = mixer_value->ctl_index;
         path->setting[path_index].num_values = num_values;
         path->setting[path_index].value = malloc(num_values * sizeof(int));
-        path->setting[path_index].linked = true;
         path->setting[path_index].value[0] = mixer_value->value;
     }
 
     if (mixer_value->index == -1) {
-        /* Linked, so only set the first value */
-        path->setting[path_index].linked = true;
-        path->setting[path_index].value[0] = mixer_value->value;
+        /* set all values the same */
+        for (i = 0; i < num_values; i++)
+            path->setting[path_index].value[i] = mixer_value->value;
     } else {
-        if (path->setting[path_index].linked && (num_values > 1)) {
-            /* Unlinking the values, so duplicate them across */
-            for (i = 1; i < num_values; i++) {
-                path->setting[path_index].value[i] =
-                        path->setting[path_index].value[0];
-            }
-            path->setting[path_index].linked = false;
-        }
+        /* set only one value */
         path->setting[path_index].value[mixer_value->index] = mixer_value->value;
     }
 
     return 0;
 }
 
-static int path_add_path(struct mixer_path *path, struct mixer_path *sub_path)
+static int path_add_path(struct audio_route *ar, struct mixer_path *path,
+                         struct mixer_path *sub_path)
 {
     unsigned int i;
 
     for (i = 0; i < sub_path->length; i++)
-        if (path_add_setting(path, &sub_path->setting[i]) < 0)
+        if (path_add_setting(ar, path, &sub_path->setting[i]) < 0)
             return -1;
 
     return 0;
@@ -295,24 +288,14 @@ static int path_add_path(struct mixer_path *path, struct mixer_path *sub_path)
 static int path_apply(struct audio_route *ar, struct mixer_path *path)
 {
     unsigned int i;
-    unsigned int j;
     unsigned int ctl_index;
 
     for (i = 0; i < path->length; i++) {
-        struct mixer_ctl *ctl = path->setting[i].ctl;
-
-        /* locate the mixer ctl in the list */
-        for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++)
-            if (ar->mixer_state[ctl_index].ctl == ctl)
-                break;
+        ctl_index = path->setting[i].ctl_index;
 
         /* apply the new value(s) */
-        for (j = 0; j < ar->mixer_state[ctl_index].num_values; j++) {
-            ar->mixer_state[ctl_index].new_value[j] = path->setting[i].value[j];
-            if (path->setting[i].linked)
-                break;
-        }
-        ar->mixer_state[ctl_index].new_linked = path->setting[i].linked;
+        memcpy(ar->mixer_state[ctl_index].new_value, path->setting[i].value,
+               path->setting[i].num_values * sizeof(int));
     }
 
     return 0;
@@ -325,21 +308,12 @@ static int path_reset(struct audio_route *ar, struct mixer_path *path)
     unsigned int ctl_index;
 
     for (i = 0; i < path->length; i++) {
-        struct mixer_ctl *ctl = path->setting[i].ctl;
-
-        /* locate the mixer ctl in the list */
-        for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++) {
-            if (ar->mixer_state[ctl_index].ctl == ctl)
-                break;
-        }
+        ctl_index = path->setting[i].ctl_index;
 
         /* reset the value(s) */
-        for (j = 0; j < ar->mixer_state[ctl_index].num_values; j++) {
-            ar->mixer_state[ctl_index].new_value[j] = ar->mixer_state[ctl_index].reset_value[j];
-            if (ar->mixer_state[ctl_index].reset_linked)
-                break;
-        }
-        ar->mixer_state[ctl_index].new_linked = ar->mixer_state[ctl_index].reset_linked;
+        memcpy(ar->mixer_state[ctl_index].new_value,
+               ar->mixer_state[ctl_index].reset_value,
+               ar->mixer_state[ctl_index].num_values * sizeof(int));
     }
 
     return 0;
@@ -395,7 +369,7 @@ static void start_tag(void *data, const XML_Char *tag_name,
             } else {
                 /* nested path */
                 struct mixer_path *sub_path = path_get_by_name(ar, attr_name);
-                path_add_path(state->path, sub_path);
+                path_add_path(ar, state->path, sub_path);
             }
         }
     }
@@ -403,6 +377,11 @@ static void start_tag(void *data, const XML_Char *tag_name,
     else if (strcmp(tag_name, "ctl") == 0) {
         /* Obtain the mixer ctl and value */
         ctl = mixer_get_ctl_by_name(ar->mixer, attr_name);
+        if (ctl == NULL) {
+            ALOGE("Control '%s' doesn't exist - skipping", attr_name);
+            goto done;
+        }
+
         switch (mixer_ctl_get_type(ctl)) {
         case MIXER_CTL_TYPE_BOOL:
         case MIXER_CTL_TYPE_INT:
@@ -416,52 +395,42 @@ static void start_tag(void *data, const XML_Char *tag_name,
             break;
         }
 
+        /* locate the mixer ctl in the list */
+        for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++) {
+            if (ar->mixer_state[ctl_index].ctl == ctl)
+                break;
+        }
+
         if (state->level == 1) {
             /* top level ctl (initial setting) */
 
-            /* locate the mixer ctl in the list */
-            for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++) {
-                if (ar->mixer_state[ctl_index].ctl == ctl)
-                    break;
-            }
-
             /* apply the new value */
             if (attr_id) {
                 /* set only one value */
                 id = atoi((char *)attr_id);
-                if (id < ar->mixer_state[ctl_index].num_values) {
-                    if (ar->mixer_state[ctl_index].new_linked) {
-                        /*
-                         * We're unlinking the values, so copy old_value[0] into
-                         * all the new_value elements.
-                         */
-                        for (i = 0; i < ar->mixer_state[ctl_index].num_values; i++) {
-                            ar->mixer_state[ctl_index].new_value[i] =
-                                    ar->mixer_state[ctl_index].old_value[0];
-                        }
-                        ar->mixer_state[ctl_index].new_linked = false;
-                    }
+                if (id < ar->mixer_state[ctl_index].num_values)
                     ar->mixer_state[ctl_index].new_value[id] = value;
-                } else {
+                else
                     ALOGE("value id out of range for mixer ctl '%s'",
                           mixer_ctl_get_name(ctl));
-                }
             } else {
-                ar->mixer_state[ctl_index].new_value[0] = value;
-                ar->mixer_state[ctl_index].new_linked = true;
+                /* set all values the same */
+                for (i = 0; i < ar->mixer_state[ctl_index].num_values; i++)
+                    ar->mixer_state[ctl_index].new_value[i] = value;
             }
         } else {
             /* nested ctl (within a path) */
-            mixer_value.ctl = ctl;
+            mixer_value.ctl_index = ctl_index;
             mixer_value.value = value;
             if (attr_id)
                 mixer_value.index = atoi((char *)attr_id);
             else
                 mixer_value.index = -1;
-            path_add_value(state->path, &mixer_value);
+            path_add_value(ar, state->path, &mixer_value);
         }
     }
 
+done:
     state->level++;
 }
 
@@ -478,7 +447,7 @@ static int alloc_mixer_state(struct audio_route *ar)
     unsigned int j;
     unsigned int num_values;
     struct mixer_ctl *ctl;
-    bool linked;
+    enum mixer_ctl_type type;
 
     ar->num_mixer_ctls = mixer_get_num_ctls(ar->mixer);
     ar->mixer_state = malloc(ar->num_mixer_ctls * sizeof(struct mixer_state));
@@ -489,32 +458,25 @@ static int alloc_mixer_state(struct audio_route *ar)
         ctl = mixer_get_ctl(ar->mixer, i);
         num_values = mixer_ctl_get_num_values(ctl);
 
+        ar->mixer_state[i].ctl = ctl;
+        ar->mixer_state[i].num_values = num_values;
+
+        /* Skip unsupported types that are not supported yet in XML */
+        type = mixer_ctl_get_type(ctl);
+        if ((type != MIXER_CTL_TYPE_BOOL) && (type != MIXER_CTL_TYPE_INT) &&
+            (type != MIXER_CTL_TYPE_ENUM))
+            continue;
+
         ar->mixer_state[i].old_value = malloc(num_values * sizeof(int));
         ar->mixer_state[i].new_value = malloc(num_values * sizeof(int));
         ar->mixer_state[i].reset_value = malloc(num_values * sizeof(int));
 
-        /*
-         * Get all mixer values for controls with multiple values. If all
-         * values are the same, set the linked flag.
-         */
-        linked = true;
-        for (j = 0; j < num_values; j++) {
-            ar->mixer_state[i].old_value[j] = mixer_ctl_get_value(ctl, j);
-            ar->mixer_state[i].new_value[j] = ar->mixer_state[i].old_value[j];
-
-            /*
-             * If the next value is different from the last, set linked to
-             * false.
-             */
-            if ((j > 0) && (ar->mixer_state[i].old_value[j - 1] !=
-                            ar->mixer_state[i].old_value[j])) {
-                linked = false;
-            }
-        }
-        ar->mixer_state[i].ctl = ctl;
-        ar->mixer_state[i].old_linked = linked;
-        ar->mixer_state[i].new_linked = linked;
-        ar->mixer_state[i].num_values = num_values;
+        if (type == MIXER_CTL_TYPE_ENUM)
+            ar->mixer_state[i].old_value[0] = mixer_ctl_get_value(ctl, 0);
+        else
+            mixer_ctl_get_array(ctl, ar->mixer_state[i].old_value, num_values);
+        memcpy(ar->mixer_state[i].new_value, ar->mixer_state[i].old_value,
+               num_values * sizeof(int));
     }
 
     return 0;
@@ -539,37 +501,36 @@ int audio_route_update_mixer(struct audio_route *ar)
 {
     unsigned int i;
     unsigned int j;
+    struct mixer_ctl *ctl;
 
     for (i = 0; i < ar->num_mixer_ctls; i++) {
         unsigned int num_values = ar->mixer_state[i].num_values;
+        enum mixer_ctl_type type;
+
+        ctl = ar->mixer_state[i].ctl;
+
+        /* Skip unsupported types */
+        type = mixer_ctl_get_type(ctl);
+        if ((type != MIXER_CTL_TYPE_BOOL) && (type != MIXER_CTL_TYPE_INT) &&
+            (type != MIXER_CTL_TYPE_ENUM))
+            continue;
 
         /* if the value has changed, update the mixer */
-        if (ar->mixer_state[i].new_linked) {
-            if (ar->mixer_state[i].old_value[0] != ar->mixer_state[i].new_value[0]) {
-                /* linked ctl, so set all ctl values the same */
-                for (j = 0; j < num_values; j++)
-                    mixer_ctl_set_value(ar->mixer_state[i].ctl, j,
-                                        ar->mixer_state[i].new_value[0]);
-                ar->mixer_state[i].old_value[0] = ar->mixer_state[i].new_value[0];
-            }
-        } else {
-            for (j = 0; j < num_values; j++) {
-                /*
-                 * unlinked ctl, so set each value if necessary.
-                 * Note that if the new value is unlinked but the old is
-                 * linked, only value 0 is valid, so we always have to
-                 * update the mixer for the other values.
-                 */
-                if (ar->mixer_state[i].old_linked ||
-                    (ar->mixer_state[i].old_value[j] !=
-                            ar->mixer_state[i].new_value[j])) {
-                    mixer_ctl_set_value(ar->mixer_state[i].ctl, j,
-                                        ar->mixer_state[i].new_value[j]);
-                    ar->mixer_state[i].old_value[j] = ar->mixer_state[i].new_value[j];
-                }
+        bool changed = false;
+        for (j = 0; j < num_values; j++) {
+            if (ar->mixer_state[i].old_value[j] != ar->mixer_state[i].new_value[j]) {
+                changed = true;
+                break;
             }
         }
-        ar->mixer_state[i].old_linked = ar->mixer_state[i].new_linked;
+        if (changed) {
+            if (type == MIXER_CTL_TYPE_ENUM)
+                mixer_ctl_set_value(ctl, 0, ar->mixer_state[i].new_value[0]);
+            else
+                mixer_ctl_set_array(ctl, ar->mixer_state[i].new_value, num_values);
+            memcpy(ar->mixer_state[i].old_value, ar->mixer_state[i].new_value,
+                   num_values * sizeof(int));
+        }
     }
 
     return 0;
@@ -579,17 +540,10 @@ int audio_route_update_mixer(struct audio_route *ar)
 static void save_mixer_state(struct audio_route *ar)
 {
     unsigned int i;
-    unsigned int j;
 
     for (i = 0; i < ar->num_mixer_ctls; i++) {
-        for (j = 0; j < ar->mixer_state[i].num_values; j++) {
-            ar->mixer_state[i].reset_value[j] = ar->mixer_state[i].new_value[j];
-
-            /* if the values are linked, only need to save value 0 */
-            if (ar->mixer_state[i].new_linked)
-                break;
-        }
-        ar->mixer_state[i].reset_linked = ar->mixer_state[i].new_linked;
+        memcpy(ar->mixer_state[i].reset_value, ar->mixer_state[i].new_value,
+               ar->mixer_state[i].num_values * sizeof(int));
     }
 }
 
@@ -597,18 +551,11 @@ static void save_mixer_state(struct audio_route *ar)
 void audio_route_reset(struct audio_route *ar)
 {
     unsigned int i;
-    unsigned int j;
 
     /* load all of the saved values */
     for (i = 0; i < ar->num_mixer_ctls; i++) {
-        for (j = 0; j < ar->mixer_state[i].num_values; j++) {
-            ar->mixer_state[i].new_value[j] = ar->mixer_state[i].reset_value[j];
-
-            /* if the values are linked, only need to save value 0 */
-            if (ar->mixer_state[i].reset_linked)
-                break;
-        }
-        ar->mixer_state[i].new_linked = ar->mixer_state[i].reset_linked;
+        memcpy(ar->mixer_state[i].new_value, ar->mixer_state[i].reset_value,
+               ar->mixer_state[i].num_values * sizeof(int));
     }
 }
 
diff --git a/audio_utils/include/audio_utils/primitives.h b/audio_utils/include/audio_utils/primitives.h
index b34e309c..358563f3 100644
--- a/audio_utils/include/audio_utils/primitives.h
+++ b/audio_utils/include/audio_utils/primitives.h
@@ -32,6 +32,8 @@ __BEGIN_DECLS
  * For mono, c is the number of samples / 2, and out is an array of 16-bit samples.
  * The name "dither" is a misnomer; the current implementation does not actually dither
  * but uses truncation.  This may change.
+ * The out and sums buffers must either be completely separate (non-overlapping), or
+ * they must both start at the same address.  Partially overlapping buffers are not supported.
  */
 void ditherAndClamp(int32_t* out, const int32_t *sums, size_t c);
 
@@ -56,6 +58,29 @@ void memcpy_to_i16_from_u8(int16_t *dst, const uint8_t *src, size_t count);
  */
 void memcpy_to_u8_from_i16(uint8_t *dst, const int16_t *src, size_t count);
 
+/* Shrink and copy samples from signed 32-bit fixed-point Q0.31 to signed 16-bit Q0.15.
+ * Parameters:
+ *  dst     Destination buffer
+ *  src     Source buffer
+ *  count   Number of samples to copy
+ * The destination and source buffers must either be completely separate (non-overlapping), or
+ * they must both start at the same address.  Partially overlapping buffers are not supported.
+ * The conversion is done by truncation, without dithering, so it loses resolution.
+ */
+void memcpy_to_i16_from_i32(int16_t *dst, const int32_t *src, size_t count);
+
+/* Shrink and copy samples from single-precision floating-point to signed 16-bit.
+ * Each float should be in the range -1.0 to 1.0.  Values outside that range are clamped.
+ * Parameters:
+ *  dst     Destination buffer
+ *  src     Source buffer
+ *  count   Number of samples to copy
+ * The destination and source buffers must either be completely separate (non-overlapping), or
+ * they must both start at the same address.  Partially overlapping buffers are not supported.
+ * The conversion is done by truncation, without dithering, so it loses resolution.
+ */
+void memcpy_to_i16_from_float(int16_t *dst, const float *src, size_t count);
+
 /* Downmix pairs of interleaved stereo input 16-bit samples to mono output 16-bit samples.
  * Parameters:
  *  dst     Destination buffer
diff --git a/audio_utils/include/audio_utils/sndfile.h b/audio_utils/include/audio_utils/sndfile.h
index c6526549..cf715b4e 100644
--- a/audio_utils/include/audio_utils/sndfile.h
+++ b/audio_utils/include/audio_utils/sndfile.h
@@ -48,9 +48,11 @@ typedef struct SNDFILE_ SNDFILE;
 // Format
 #define SF_FORMAT_TYPEMASK  1
 #define SF_FORMAT_WAV       1
-#define SF_FORMAT_SUBMASK   6
+#define SF_FORMAT_SUBMASK   14
 #define SF_FORMAT_PCM_16    2
 #define SF_FORMAT_PCM_U8    4
+#define SF_FORMAT_FLOAT     6
+#define SF_FORMAT_PCM_32    8
 
 // Open stream
 SNDFILE *sf_open(const char *path, int mode, SF_INFO *info);
@@ -60,9 +62,11 @@ void sf_close(SNDFILE *handle);
 
 // Read interleaved frames and return actual number of frames read
 sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desired);
+sf_count_t sf_readf_float(SNDFILE *handle, float *ptr, sf_count_t desired);
 
 // Write interleaved frames and return actual number of frames written
 sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desired);
+sf_count_t sf_writef_float(SNDFILE *handle, const float *ptr, sf_count_t desired);
 
 __END_DECLS
 
diff --git a/audio_utils/primitives.c b/audio_utils/primitives.c
index af9ab40c..90ad75a0 100644
--- a/audio_utils/primitives.c
+++ b/audio_utils/primitives.c
@@ -16,7 +16,7 @@
 
 #include <audio_utils/primitives.h>
 
-void ditherAndClamp(int32_t* out, int32_t const *sums, size_t c)
+void ditherAndClamp(int32_t* out, const int32_t *sums, size_t c)
 {
     size_t i;
     for (i=0 ; i<c ; i++) {
@@ -46,6 +46,30 @@ void memcpy_to_u8_from_i16(uint8_t *dst, const int16_t *src, size_t count)
     }
 }
 
+void memcpy_to_i16_from_i32(int16_t *dst, const int32_t *src, size_t count)
+{
+    while (count--) {
+        *dst++ = *src++ >> 16;
+    }
+}
+
+void memcpy_to_i16_from_float(int16_t *dst, const float *src, size_t count)
+{
+    while (count--) {
+        float f = *src++;
+        int16_t i;
+        if (f > 1.0) {
+            i = 32767;
+        } else if (f < -1.0) {
+            i = -32768;
+        } else {
+            // does not specifically handle NaN
+            i = f * 32767.0;
+        }
+        *dst++ = i;
+    }
+}
+
 void downmix_to_mono_i16_from_stereo_i16(int16_t *dst, const int16_t *src, size_t count)
 {
     while (count--) {
diff --git a/audio_utils/tinysndfile.c b/audio_utils/tinysndfile.c
index 2b58d16b..cc4ff895 100644
--- a/audio_utils/tinysndfile.c
+++ b/audio_utils/tinysndfile.c
@@ -18,6 +18,11 @@
 #include <audio_utils/primitives.h>
 #include <stdio.h>
 #include <string.h>
+#include <errno.h>
+
+#define WAVE_FORMAT_PCM         1
+#define WAVE_FORMAT_IEEE_FLOAT  3
+#define WAVE_FORMAT_EXTENSIBLE  0xFFFE
 
 struct SNDFILE_ {
     int mode;
@@ -57,60 +62,172 @@ static void my_swab(short *ptr, size_t numToSwap)
 static SNDFILE *sf_open_read(const char *path, SF_INFO *info)
 {
     FILE *stream = fopen(path, "rb");
-    if (stream == NULL)
+    if (stream == NULL) {
+        fprintf(stderr, "fopen %s failed errno %d\n", path, errno);
         return NULL;
-    // don't attempt to parse all valid forms, just the most common one
-    unsigned char wav[44];
+    }
+
+    SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
+    handle->mode = SFM_READ;
+    handle->temp = NULL;
+    handle->stream = stream;
+    handle->info.format = SF_FORMAT_WAV;
+
+    // don't attempt to parse all valid forms, just the most common ones
+    unsigned char wav[12];
     size_t actual;
     actual = fread(wav, sizeof(char), sizeof(wav), stream);
-    if (actual != sizeof(wav))
-        return NULL;
-    for (;;) {
-        if (memcmp(wav, "RIFF", 4))
-            break;
-        unsigned riffSize = little4u(&wav[4]);
-        if (riffSize < 36)
-            break;
-        if (memcmp(&wav[8], "WAVEfmt ", 8))
-            break;
-        unsigned fmtsize = little4u(&wav[16]);
-        if (fmtsize != 16)
-            break;
-        unsigned format = little2u(&wav[20]);
-        if (format != 1)    // PCM
-            break;
-        unsigned channels = little2u(&wav[22]);
-        if (channels != 1 && channels != 2)
-            break;
-        unsigned samplerate = little4u(&wav[24]);
-        if (samplerate == 0)
-            break;
-        // ignore byte rate
-        // ignore block alignment
-        unsigned bitsPerSample = little2u(&wav[34]);
-        if (bitsPerSample != 8 && bitsPerSample != 16)
-            break;
-        unsigned bytesPerFrame = (bitsPerSample >> 3) * channels;
-        if (memcmp(&wav[36], "data", 4))
-            break;
-        unsigned dataSize = little4u(&wav[40]);
-        SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
-        handle->mode = SFM_READ;
-        handle->temp = NULL;
-        handle->stream = stream;
-        handle->bytesPerFrame = bytesPerFrame;
-        handle->remaining = dataSize / bytesPerFrame;
-        handle->info.frames = handle->remaining;
-        handle->info.samplerate = samplerate;
-        handle->info.channels = channels;
-        handle->info.format = SF_FORMAT_WAV;
-        if (bitsPerSample == 8)
-            handle->info.format |= SF_FORMAT_PCM_U8;
-        else
-            handle->info.format |= SF_FORMAT_PCM_16;
-        *info = handle->info;
-        return handle;
+    if (actual < 12) {
+        fprintf(stderr, "actual %u < 44\n", actual);
+        goto close;
+    }
+    if (memcmp(wav, "RIFF", 4)) {
+        fprintf(stderr, "wav != RIFF\n");
+        goto close;
+    }
+    unsigned riffSize = little4u(&wav[4]);
+    if (riffSize < 4) {
+        fprintf(stderr, "riffSize %u < 4\n", riffSize);
+        goto close;
+    }
+    if (memcmp(&wav[8], "WAVE", 4)) {
+        fprintf(stderr, "missing WAVE\n");
+        goto close;
+    }
+    size_t remaining = riffSize - 4;
+    int hadFmt = 0;
+    int hadData = 0;
+    while (remaining >= 8) {
+        unsigned char chunk[8];
+        actual = fread(chunk, sizeof(char), sizeof(chunk), stream);
+        if (actual != sizeof(chunk)) {
+            fprintf(stderr, "actual %u != %u\n", actual, sizeof(chunk));
+            goto close;
+        }
+        remaining -= 8;
+        unsigned chunkSize = little4u(&chunk[4]);
+        if (chunkSize > remaining) {
+            fprintf(stderr, "chunkSize %u > remaining %u\n", chunkSize, remaining);
+            goto close;
+        }
+        if (!memcmp(&chunk[0], "fmt ", 4)) {
+            if (hadFmt) {
+                fprintf(stderr, "multiple fmt\n");
+                goto close;
+            }
+            if (chunkSize < 2) {
+                fprintf(stderr, "chunkSize %u < 2\n", chunkSize);
+                goto close;
+            }
+            unsigned char fmt[40];
+            actual = fread(fmt, sizeof(char), 2, stream);
+            if (actual != 2) {
+                fprintf(stderr, "actual %u != 2\n", actual);
+                goto close;
+            }
+            unsigned format = little2u(&fmt[0]);
+            size_t minSize = 0;
+            switch (format) {
+            case WAVE_FORMAT_PCM:
+            case WAVE_FORMAT_IEEE_FLOAT:
+                minSize = 16;
+                break;
+            case WAVE_FORMAT_EXTENSIBLE:
+                minSize = 40;
+                break;
+            default:
+                fprintf(stderr, "unsupported format %u\n", format);
+                goto close;
+            }
+            if (chunkSize < minSize) {
+                fprintf(stderr, "chunkSize %u < minSize %u\n", chunkSize, minSize);
+                goto close;
+            }
+            actual = fread(&fmt[2], sizeof(char), minSize - 2, stream);
+            if (actual != minSize - 2) {
+                fprintf(stderr, "actual %u != %u\n", actual, minSize - 16);
+                goto close;
+            }
+            if (chunkSize > minSize) {
+                fseek(stream, (long) (chunkSize - minSize), SEEK_CUR);
+            }
+            unsigned channels = little2u(&fmt[2]);
+            if (channels != 1 && channels != 2) {
+                fprintf(stderr, "channels %u != 1 or 2\n", channels);
+                goto close;
+            }
+            unsigned samplerate = little4u(&fmt[4]);
+            if (samplerate == 0) {
+                fprintf(stderr, "samplerate %u == 0\n", samplerate);
+                goto close;
+            }
+            // ignore byte rate
+            // ignore block alignment
+            unsigned bitsPerSample = little2u(&fmt[14]);
+            if (bitsPerSample != 8 && bitsPerSample != 16 && bitsPerSample != 32) {
+                fprintf(stderr, "bitsPerSample %u != 8 or 16 or 32\n", bitsPerSample);
+                goto close;
+            }
+            unsigned bytesPerFrame = (bitsPerSample >> 3) * channels;
+            handle->bytesPerFrame = bytesPerFrame;
+            handle->info.samplerate = samplerate;
+            handle->info.channels = channels;
+            switch (bitsPerSample) {
+            case 8:
+                handle->info.format |= SF_FORMAT_PCM_U8;
+                break;
+            case 16:
+                handle->info.format |= SF_FORMAT_PCM_16;
+                break;
+            case 32:
+                if (format == WAVE_FORMAT_IEEE_FLOAT)
+                    handle->info.format |= SF_FORMAT_FLOAT;
+                else
+                    handle->info.format |= SF_FORMAT_PCM_32;
+                break;
+            }
+            hadFmt = 1;
+        } else if (!memcmp(&chunk[0], "data", 4)) {
+            if (!hadFmt) {
+                fprintf(stderr, "data not preceded by fmt\n");
+                goto close;
+            }
+            if (hadData) {
+                fprintf(stderr, "multiple data\n");
+                goto close;
+            }
+            handle->remaining = chunkSize / handle->bytesPerFrame;
+            handle->info.frames = handle->remaining;
+            hadData = 1;
+        } else if (!memcmp(&chunk[0], "fact", 4)) {
+            // ignore fact
+            if (chunkSize > 0) {
+                fseek(stream, (long) chunkSize, SEEK_CUR);
+            }
+        } else {
+            // ignore unknown chunk
+            fprintf(stderr, "ignoring unknown chunk %c%c%c%c\n",
+                    chunk[0], chunk[1], chunk[2], chunk[3]);
+            if (chunkSize > 0) {
+                fseek(stream, (long) chunkSize, SEEK_CUR);
+            }
+        }
+        remaining -= chunkSize;
+    }
+    if (remaining > 0) {
+        fprintf(stderr, "partial chunk at end of RIFF, remaining %u\n", remaining);
+        goto close;
     }
+    if (!hadData) {
+        fprintf(stderr, "missing data\n");
+        goto close;
+    }
+    *info = handle->info;
+    return handle;
+
+close:
+    free(handle);
+    fclose(stream);
     return NULL;
 }
 
@@ -124,32 +241,57 @@ static void write4u(unsigned char *ptr, unsigned u)
 
 static SNDFILE *sf_open_write(const char *path, SF_INFO *info)
 {
+    int sub = info->format & SF_FORMAT_SUBMASK;
     if (!(
             (info->samplerate > 0) &&
             (info->channels == 1 || info->channels == 2) &&
             ((info->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV) &&
-            ((info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_16 ||
-             (info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_U8)
+            (sub == SF_FORMAT_PCM_16 || sub == SF_FORMAT_PCM_U8 || sub == SF_FORMAT_FLOAT)
           )) {
         return NULL;
     }
     FILE *stream = fopen(path, "w+b");
-    unsigned char wav[44];
+    unsigned char wav[58];
     memset(wav, 0, sizeof(wav));
     memcpy(wav, "RIFF", 4);
-    wav[4] = 36;    // riffSize
     memcpy(&wav[8], "WAVEfmt ", 8);
-    wav[16] = 16;   // fmtsize
-    wav[20] = 1;    // format = PCM
+    if (sub == SF_FORMAT_FLOAT) {
+        wav[4] = 50;    // riffSize
+        wav[16] = 18;   // fmtSize
+        wav[20] = WAVE_FORMAT_IEEE_FLOAT;
+    } else {
+        wav[4] = 36;    // riffSize
+        wav[16] = 16;   // fmtSize
+        wav[20] = WAVE_FORMAT_PCM;
+    }
     wav[22] = info->channels;
     write4u(&wav[24], info->samplerate);
-    unsigned bitsPerSample = (info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_16 ? 16 : 8;
+    unsigned bitsPerSample;
+    switch (sub) {
+    case SF_FORMAT_PCM_16:
+        bitsPerSample = 16;
+        break;
+    case SF_FORMAT_PCM_U8:
+        bitsPerSample = 8;
+        break;
+    case SF_FORMAT_FLOAT:
+        bitsPerSample = 32;
+        break;
+    default:    // not reachable
+        bitsPerSample = 0;
+        break;
+    }
     unsigned blockAlignment = (bitsPerSample >> 3) * info->channels;
     unsigned byteRate = info->samplerate * blockAlignment;
     write4u(&wav[28], byteRate);
     wav[32] = blockAlignment;
     wav[34] = bitsPerSample;
-    memcpy(&wav[36], "data", 4);
+    if (sub == SF_FORMAT_FLOAT) {
+        memcpy(&wav[38], "fact", 4);
+        wav[42] = 4;
+        memcpy(&wav[50], "data", 4);
+    } else
+        memcpy(&wav[36], "data", 4);
     // dataSize is initially zero
     (void) fwrite(wav, sizeof(wav), 1, stream);
     SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
@@ -164,14 +306,17 @@ static SNDFILE *sf_open_write(const char *path, SF_INFO *info)
 
 SNDFILE *sf_open(const char *path, int mode, SF_INFO *info)
 {
-    if (path == NULL || info == NULL)
+    if (path == NULL || info == NULL) {
+        fprintf(stderr, "path=%p info=%p\n", path, info);
         return NULL;
+    }
     switch (mode) {
     case SFM_READ:
         return sf_open_read(path, info);
     case SFM_WRITE:
         return sf_open_write(path, info);
     default:
+        fprintf(stderr, "mode=%d\n", mode);
         return NULL;
     }
 }
@@ -184,13 +329,14 @@ void sf_close(SNDFILE *handle)
     if (handle->mode == SFM_WRITE) {
         (void) fflush(handle->stream);
         rewind(handle->stream);
-        unsigned char wav[44];
-        (void) fread(wav, sizeof(wav), 1, handle->stream);
+        unsigned char wav[58];
+        size_t extra = (handle->info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT ? 14 : 0;
+        (void) fread(wav, 44 + extra, 1, handle->stream);
         unsigned dataSize = handle->remaining * handle->bytesPerFrame;
-        write4u(&wav[4], dataSize + 36);    // riffSize
-        write4u(&wav[40], dataSize);        // dataSize
+        write4u(&wav[4], dataSize + 36 + extra);    // riffSize
+        write4u(&wav[40 + extra], dataSize);        // dataSize
         rewind(handle->stream);
-        (void) fwrite(wav, sizeof(wav), 1, handle->stream);
+        (void) fwrite(wav, 44 + extra, 1, handle->stream);
     }
     (void) fclose(handle->stream);
     free(handle);
@@ -204,12 +350,20 @@ sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desiredFrames)
     }
     if (handle->remaining < (size_t) desiredFrames)
         desiredFrames = handle->remaining;
-    size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
     // does not check for numeric overflow
-    size_t actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
+    size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
+    size_t actualBytes;
+    void *temp = NULL;
+    unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
+    if (format == SF_FORMAT_PCM_32 || format == SF_FORMAT_FLOAT) {
+        temp = malloc(desiredBytes);
+        actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
+    } else {
+        actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
+    }
     size_t actualFrames = actualBytes / handle->bytesPerFrame;
     handle->remaining -= actualFrames;
-    switch (handle->info.format & SF_FORMAT_SUBMASK) {
+    switch (format) {
     case SF_FORMAT_PCM_U8:
         memcpy_to_i16_from_u8(ptr, (unsigned char *) ptr, actualFrames * handle->info.channels);
         break;
@@ -217,10 +371,26 @@ sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desiredFrames)
         if (!isLittleEndian())
             my_swab(ptr, actualFrames * handle->info.channels);
         break;
+    case SF_FORMAT_PCM_32:
+        memcpy_to_i16_from_i32(ptr, (const int *) temp, actualFrames * handle->info.channels);
+        free(temp);
+        break;
+    case SF_FORMAT_FLOAT:
+        memcpy_to_i16_from_float(ptr, (const float *) temp, actualFrames * handle->info.channels);
+        free(temp);
+        break;
+    default:
+        memset(ptr, 0, actualFrames * handle->info.channels * sizeof(short));
+        break;
     }
     return actualFrames;
 }
 
+sf_count_t sf_readf_float(SNDFILE *handle, float *ptr, sf_count_t desiredFrames)
+{
+    return 0;
+}
+
 sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desiredFrames)
 {
     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
@@ -244,6 +414,29 @@ sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desired
             actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
         }
         break;
+    case SF_FORMAT_FLOAT:   // transcoding from short to float not yet implemented
+    default:
+        break;
+    }
+    size_t actualFrames = actualBytes / handle->bytesPerFrame;
+    handle->remaining += actualFrames;
+    return actualFrames;
+}
+
+sf_count_t sf_writef_float(SNDFILE *handle, const float *ptr, sf_count_t desiredFrames)
+{
+    if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
+        return 0;
+    size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
+    size_t actualBytes = 0;
+    switch (handle->info.format & SF_FORMAT_SUBMASK) {
+    case SF_FORMAT_FLOAT:
+        actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
+        break;
+    case SF_FORMAT_PCM_U8:  // transcoding from float to byte/short not yet implemented
+    case SF_FORMAT_PCM_16:
+    default:
+        break;
     }
     size_t actualFrames = actualBytes / handle->bytesPerFrame;
     handle->remaining += actualFrames;
diff --git a/camera/docs/.gitignore b/camera/docs/.gitignore
new file mode 100644
index 00000000..0d20b648
--- /dev/null
+++ b/camera/docs/.gitignore
@@ -0,0 +1 @@
+*.pyc
diff --git a/camera/docs/CameraCaptureResultTest.mako b/camera/docs/CameraCaptureResultTest.mako
new file mode 100644
index 00000000..4b325bda
--- /dev/null
+++ b/camera/docs/CameraCaptureResultTest.mako
@@ -0,0 +1,42 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+    /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * The key entries below this point are generated from metadata
+     * definitions in /system/media/camera/docs. Do not modify by hand or
+     * modify the comment blocks at the start or end.
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/
+
+    private static List<CameraMetadata.Key<?>> getAllCaptureResultKeys() {
+        ArrayList<CameraMetadata.Key<?>> resultKeys = new ArrayList<CameraMetadata.Key<?>>();
+% for sec in find_all_sections(metadata):
+  % for entry in find_unique_entries(sec):
+    % if entry.kind == 'dynamic' and entry.visibility == "public":
+        resultKeys.add(CaptureResult.${jkey_identifier(entry.name)});
+    % endif
+  % endfor
+% endfor
+
+        // Add STATISTICS_FACES key separately here because it is not
+        // defined in metadata xml file.
+        resultKeys.add(CaptureResult.STATISTICS_FACES);
+
+        return resultKeys;
+    }
+
+    /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * End generated code
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/
diff --git a/camera/docs/CameraCharacteristicsKeys.mako b/camera/docs/CameraCharacteristicsKeys.mako
new file mode 100644
index 00000000..5d2d7e41
--- /dev/null
+++ b/camera/docs/CameraCharacteristicsKeys.mako
@@ -0,0 +1,17 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+<%include file="CameraMetadataKeys.mako" args="java_class='CameraCharacteristics', xml_kind='static'" />
diff --git a/camera/docs/CameraCharacteristicsTest.mako b/camera/docs/CameraCharacteristicsTest.mako
new file mode 100644
index 00000000..a983e672
--- /dev/null
+++ b/camera/docs/CameraCharacteristicsTest.mako
@@ -0,0 +1,96 @@
+## -*- coding: utf-8 -*-
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from system/media/camera/docs/CameraCharacteristicsTest.mako.
+ * This file contains only the auto-generated CameraCharacteristics CTS tests; it does
+ * not contain any additional manual tests, which would be in a separate file.
+ */
+
+package android.hardware.camera2.cts;
+
+import android.content.Context;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CameraMetadata.Key;
+import android.test.AndroidTestCase;
+import android.util.Log;
+
+import java.util.List;
+
+/**
+ * Auto-generated CTS test for CameraCharacteristics fields.
+ */
+public class CameraCharacteristicsTest extends AndroidTestCase {
+    private CameraManager mCameraManager;
+    private static final String TAG = "CameraCharacteristicsTest";
+
+    @Override
+    public void setContext(Context context) {
+        super.setContext(context);
+        mCameraManager = (CameraManager)context.getSystemService(Context.CAMERA_SERVICE);
+        assertNotNull("Can't connect to camera manager", mCameraManager);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
+    % for sec in find_all_sections(metadata):
+      % for entry in find_unique_entries(sec):
+        % if entry.kind == 'static' and entry.visibility == "public":
+
+    public void testCameraCharacteristics${pascal_case(entry.name)}() throws Exception {
+        String[] ids = mCameraManager.getCameraIdList();
+        for (int i = 0; i < ids.length; i++) {
+            CameraCharacteristics props = mCameraManager.getCameraCharacteristics(ids[i]);
+            assertNotNull(String.format("Can't get camera characteristics from: ID %s", ids[i]),
+                                        props);
+
+          % if entry.applied_optional:
+            Integer hwLevel = props.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
+            assertNotNull("No hardware level reported! android.info.supportedHardwareLevel",
+                    hwLevel);
+            if (hwLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL)
+          % endif
+            {
+
+                assertNotNull("Invalid property: ${entry.name}",
+                        props.get(CameraCharacteristics.${jkey_identifier(entry.name)}));
+
+                List<Key<?>> allKeys = props.getKeys();
+                assertNotNull(String.format("Can't get camera characteristics keys from: ID %s",
+                        ids[i], props));
+                assertTrue("Key not in keys list: ${entry.name}", allKeys.contains(
+                        CameraCharacteristics.${jkey_identifier(entry.name)}));
+
+            }
+
+        }
+    }
+        % endif
+      % endfor
+    % endfor
+}
+
diff --git a/camera/docs/CameraMetadataEnums.mako b/camera/docs/CameraMetadataEnums.mako
new file mode 100644
index 00000000..a4bc8c73
--- /dev/null
+++ b/camera/docs/CameraMetadataEnums.mako
@@ -0,0 +1,89 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+\
+## This section of enum integer definitions is inserted into
+## android.hardware.camera2.CameraMetadata.
+    /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * The enum values below this point are generated from metadata
+     * definitions in /system/media/camera/docs. Do not modify by hand or
+     * modify the comment blocks at the start or end.
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/
+##
+## Generate an enum's integers
+<%def name="generate_enum(entry, target_class)">\
+    //
+    // Enumeration values for ${target_class}#${entry.name | jkey_identifier}
+    //
+
+  % for value in entry.enum.values:
+    /**
+    % if value.notes:
+${value.notes | javadoc}\
+    % endif
+     * @see ${target_class}#${entry.name | jkey_identifier}
+    % if entry.applied_visibility == 'hidden':
+     * @hide
+    %endif
+     */
+    public static final int ${jenum_value(entry, value)} = ${enum_calculate_value_string(value)};
+
+  % endfor
+</%def>\
+##
+## Generate a list of only Static, Controls, or Dynamic properties.
+<%def name="single_kind_keys(xml_name, target_class)">\
+% for outer_namespace in metadata.outer_namespaces: ## assumes single 'android' namespace
+  % for section in outer_namespace.sections:
+    % if section.find_first(lambda x: isinstance(x, metadata_model.Entry) and x.kind == xml_name) and \
+         any_visible(section, xml_name, ('public','hidden') ):
+      % for inner_namespace in get_children_by_filtering_kind(section, xml_name, 'namespaces'):
+## We only support 1 level of inner namespace, i.e. android.a.b and android.a.b.c works, but not android.a.b.c.d
+## If we need to support more, we should use a recursive function here instead.. but the indentation gets trickier.
+        % for entry in filter_visibility(inner_namespace.entries, ('hidden','public')):
+          % if entry.enum \
+              and not (entry.typedef and entry.typedef.languages.get('java')) \
+              and not entry.is_clone():
+${generate_enum(entry, target_class)}\
+          % endif
+        % endfor
+      % endfor
+      % for entry in filter_visibility( \
+          get_children_by_filtering_kind(section, xml_name, 'entries'), \
+                                         ('hidden', 'public')):
+        % if entry.enum \
+             and not (entry.typedef and entry.typedef.languages.get('java')) \
+             and not entry.is_clone():
+${generate_enum(entry, target_class)}\
+        % endif
+      % endfor
+    % endif
+  % endfor
+% endfor
+</%def>\
+
+##
+## Static properties only
+${single_kind_keys('static','CameraCharacteristics')}\
+##
+## Controls properties only
+${single_kind_keys('controls','CaptureRequest')}\
+##
+## Dynamic properties only
+${single_kind_keys('dynamic','CaptureResult')}\
+    /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * End generated code
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/
diff --git a/camera/docs/CameraMetadataKeys.mako b/camera/docs/CameraMetadataKeys.mako
new file mode 100644
index 00000000..815ce39e
--- /dev/null
+++ b/camera/docs/CameraMetadataKeys.mako
@@ -0,0 +1,95 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+\
+## These sections of metadata Key definitions are inserted into the middle of
+## android.hardware.camera2.CameraCharacteristics, CaptureRequest, and CaptureResult.
+<%page args="java_class, xml_kind" />\
+    /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * The key entries below this point are generated from metadata
+     * definitions in /system/media/camera/docs. Do not modify by hand or
+     * modify the comment blocks at the start or end.
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/
+
+##
+## Generate a single key and docs
+<%def name="generate_key(entry)">\
+    /**
+  % if entry.description:
+${entry.description | javadoc}\
+  % endif
+  % if entry.notes:
+${entry.notes | javadoc}\
+  % endif
+  % if entry.enum and not (entry.typedef and entry.typedef.languages.get('java')):
+    % for value in entry.enum.values:
+     * @see #${jenum_value(entry, value)}
+    % endfor
+  % endif
+  % if entry.optional:
+     *
+     * <b>Optional</b> - This value may be null on some devices.
+  % endif
+  % if any(tag.name == 'FULL' for tag in entry.tags):
+     *
+     * <b>{@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL_FULL HARDWARE_LEVEL_FULL}</b> -
+     * Present on all devices that report being FULL level hardware devices in the
+     * {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL HARDWARE_LEVEL} key.
+  % endif
+  % if entry.applied_visibility == 'hidden':
+     *
+     * @hide
+  % endif
+     */
+    public static final Key<${jtype_boxed(entry)}> ${entry.name | jkey_identifier} =
+            new Key<${jtype_boxed(entry)}>("${entry.name}", ${jclass(entry)});
+</%def>\
+##
+## Generate a list of only Static, Controls, or Dynamic properties.
+<%def name="single_kind_keys(java_name, xml_name)">\
+% for outer_namespace in metadata.outer_namespaces: ## assumes single 'android' namespace
+  % for section in outer_namespace.sections:
+    % if section.find_first(lambda x: isinstance(x, metadata_model.Entry) and x.kind == xml_name) and \
+         any_visible(section, xml_name, ('public','hidden') ):
+      % for inner_namespace in get_children_by_filtering_kind(section, xml_name, 'namespaces'):
+## We only support 1 level of inner namespace, i.e. android.a.b and android.a.b.c works, but not android.a.b.c.d
+## If we need to support more, we should use a recursive function here instead.. but the indentation gets trickier.
+        % for entry in filter_visibility(inner_namespace.merged_entries, ('hidden','public')):
+${generate_key(entry)}
+       % endfor
+    % endfor
+    % for entry in filter_visibility( \
+        get_children_by_filtering_kind(section, xml_name, 'merged_entries'), \
+                                         ('hidden', 'public')):
+${generate_key(entry)}
+    % endfor
+    % endif
+  % endfor
+% endfor
+</%def>\
+##
+## Static properties only
+##${single_kind_keys('CameraCharacteristicsKeys', 'static')}
+##
+## Controls properties only
+##${single_kind_keys('CaptureRequestKeys', 'controls')}
+##
+## Dynamic properties only
+##${single_kind_keys('CaptureResultKeys', 'dynamic')}
+${single_kind_keys(java_class, xml_kind)}\
+    /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
+     * End generated code
+     *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/
\ No newline at end of file
diff --git a/camera/docs/CaptureRequestKeys.mako b/camera/docs/CaptureRequestKeys.mako
new file mode 100644
index 00000000..bb8910fe
--- /dev/null
+++ b/camera/docs/CaptureRequestKeys.mako
@@ -0,0 +1,17 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+<%include file="CameraMetadataKeys.mako" args="java_class='CaptureRequest', xml_kind='controls'" />
diff --git a/camera/docs/CaptureResultKeys.mako b/camera/docs/CaptureResultKeys.mako
new file mode 100644
index 00000000..07bb139d
--- /dev/null
+++ b/camera/docs/CaptureResultKeys.mako
@@ -0,0 +1,17 @@
+## -*- coding: utf-8 -*-
+##
+## Copyright (C) 2013 The Android Open Source Project
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+<%include file="CameraMetadataKeys.mako" args="java_class='CaptureResult', xml_kind='dynamic'" />
diff --git a/camera/docs/camera_metadata_tags.mako b/camera/docs/camera_metadata_tags.mako
index 2bffe400..105f7e1b 100644
--- a/camera/docs/camera_metadata_tags.mako
+++ b/camera/docs/camera_metadata_tags.mako
@@ -27,6 +27,18 @@
  * Generated automatically from camera_metadata_tags.mako
  */
 
+<%!
+  def annotated_type(entry):
+    if entry.enum:
+       type = 'enum'
+    else:
+       type = entry.type
+    if entry.container == 'array':
+       type += '[]'
+
+    return type
+%>\
+\
 /** TODO: Nearly every enum in this file needs a description */
 
 /**
@@ -65,9 +77,10 @@ typedef enum camera_metadata_tag {
     % for sec in find_all_sections(metadata):
       % for idx,entry in enumerate(find_unique_entries(sec)):
         % if idx == 0:
-    ${entry.name | csym,ljust(30)} = ${path_name(find_parent_section(entry)) | csym}_START,
+    ${entry.name + " = " | csym,ljust(50)}// ${annotated_type(entry) | ljust(12)} | ${entry.applied_visibility}
+            ${path_name(find_parent_section(entry)) | csym}_START,
         % else:
-    ${entry.name | csym},
+    ${entry.name + "," | csym,ljust(50)}// ${annotated_type(entry) | ljust(12)} | ${entry.applied_visibility}
         % endif
       % endfor
     ${path_name(sec) | csym}_END,
diff --git a/camera/docs/docs.html b/camera/docs/docs.html
index 210e9d8d..d4f29fb6 100644
--- a/camera/docs/docs.html
+++ b/camera/docs/docs.html
@@ -17,31 +17,45 @@
 <head>
   <!-- automatically generated from html.mako. do NOT edit directly -->
   <meta charset="utf-8" />
-  <title>Android Camera HAL2.0 Properties</title>
+  <title>Android Camera HAL3.0 Properties</title>
   <style type="text/css">
-    .section { font-size: 1.5em; font-weight: bold; background-color: beige; padding: 0.5em 0em 0.5em 0.1em }
-    .kind { font-size: 1.2em; font-weight: bold; padding-left: 0.5em; background-color: gray }
-    .entry { background-color: burlywood }
+     body { background-color: #f7f7f7; font-family: Roboto, sans-serif;}
+     h1 { color: #333333; }
+     h2 { color: #333333; }
+     a:link { color: #258aaf; text-decoration: none}
+     a:hover { color: #459aaf; text-decoration: underline }
+     a:visited { color: #154a5f; text-decoration: none}
+    .section { color: #eeeeee; font-size: 1.5em; font-weight: bold; background-color: #888888; padding: 0.5em 0em 0.5em 0.5em; border-width: thick thin thin thin; border-color: #111111 #777777 #777777 #777777}
+    .kind { color: #eeeeee; font-size: 1.2em; font-weight: bold; padding-left: 1.5em; background-color: #aaaaaa }
+    .entry { background-color: #f0f0f0 }
+    .entries_header { background-color: #dddddd; text-align: center}
+
+    /* toc style */
+    .toc_section_header { font-size:1.3em;  }
+    .toc_kind_header { font-size:1.2em;  }
 
     /* table column sizes */
-    table { table-layout: fixed; width: 100%; word-wrap: break-word }
-    td,th { border: 1px solid;  }
+    table { border-collapse:collapse; table-layout: fixed; width: 100%; word-wrap: break-word }
+    td,th { border: 1px solid; border-color: #aaaaaa; padding-left: 0.5em; padding-right: 0.5em }
     .th_name { width: 20% }
     .th_units { width: 10% }
     .th_tags { width: 5% }
-    .th_notes { width: 30% }
+    .th_notes { width: 25% }
     .th_type { width: 20% }
+    .th_description { width: 20% }
+    .th_range { width: 10% }
     td { font-size: 0.9em; }
 
     /* hide the first thead, we need it there only to enforce column sizes */
     .thead_dummy { visibility: hidden; }
 
     /* Entry flair */
-    .entry_name { font-family: monospace; font-style: italic; }
+    .entry_name { color: #333333; padding-left:1.0em; font-size:1.1em; font-family: monospace; }
 
     /* Entry type flair */
-    .entry_type_name { color: darkgreen; font-weight: bold; }
-    .entry_type_name_enum:after { color: darkgreen; font-weight: bold; content:" (enum)" }
+    .entry_type_name { font-size:1.1em; color: #669900; font-weight: bold;}
+    .entry_type_name_enum:after { color: #669900; font-weight: bold; content:" (enum)" }
+    .entry_type_visibility { font-weight: bolder; padding-left:1em}
     .entry_type_enum_name { font-family: monospace; font-weight: bolder; }
     .entry_type_enum_notes:before { content:" - " }
     .entry_type_enum_value:before { content:" = " }
@@ -49,6 +63,8 @@
     .entry ul { margin: 0 0 0 0; list-style-position: inside; padding-left: 0.5em; }
     .entry ul li { padding: 0 0 0 0; margin: 0 0 0 0;}
 
+    /* Entry visibility flair */
+
     /* Entry tags flair */
     .entry_tags ul { list-style-type: none; }
 
@@ -73,289 +89,566 @@
 
 
 
-
 <body>
-  <h1>Android Camera HAL2.0 Properties</h1>
+  <h1>Android Camera HAL3.0 Properties</h1>
+
 
   <h2>Table of Contents</h2>
   <ul class="toc">
-    <li><a href="#tag_index">Tags</a></li>
-
-
-    <li><p class="toc_section"><a href="#section_colorCorrection">colorCorrection</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.colorCorrection.mode">android.colorCorrection.mode</a> (controls)</li>
-        <li><a href="#controls_android.colorCorrection.transform">android.colorCorrection.transform</a> (controls)</li>
-        <li><a href="#dynamic_android.colorCorrection.mode">android.colorCorrection.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_control">control</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.control.aeAntibandingMode">android.control.aeAntibandingMode</a> (controls)</li>
-        <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a> (controls)</li>
-        <li><a href="#controls_android.control.aeLock">android.control.aeLock</a> (controls)</li>
-        <li><a href="#controls_android.control.aeMode">android.control.aeMode</a> (controls)</li>
-        <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a> (controls)</li>
-        <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a> (controls)</li>
-        <li><a href="#controls_android.control.aePrecaptureTrigger">android.control.aePrecaptureTrigger</a> (controls)</li>
-        <li><a href="#controls_android.control.afMode">android.control.afMode</a> (controls)</li>
-        <li><a href="#controls_android.control.afRegions">android.control.afRegions</a> (controls)</li>
-        <li><a href="#controls_android.control.afTrigger">android.control.afTrigger</a> (controls)</li>
-        <li><a href="#controls_android.control.awbLock">android.control.awbLock</a> (controls)</li>
-        <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
-        <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a> (controls)</li>
-        <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a> (controls)</li>
-        <li><a href="#controls_android.control.effectMode">android.control.effectMode</a> (controls)</li>
-        <li><a href="#controls_android.control.mode">android.control.mode</a> (controls)</li>
-        <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a> (controls)</li>
-        <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a> (controls)</li>
-        <li><a href="#static_android.control.aeAvailableAntibandingModes">android.control.aeAvailableAntibandingModes</a> (static)</li>
-        <li><a href="#static_android.control.aeAvailableModes">android.control.aeAvailableModes</a> (static)</li>
-        <li><a href="#static_android.control.aeAvailableTargetFpsRanges">android.control.aeAvailableTargetFpsRanges</a> (static)</li>
-        <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a> (static)</li>
-        <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a> (static)</li>
-        <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a> (static)</li>
-        <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a> (static)</li>
-        <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a> (static)</li>
-        <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a> (static)</li>
-        <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a> (static)</li>
-        <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a> (static)</li>
-        <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a> (static)</li>
-        <li><a href="#dynamic_android.control.aePrecaptureId">android.control.aePrecaptureId</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.aeRegions">android.control.aeRegions</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.aeState">android.control.aeState</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.afMode">android.control.afMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.afRegions">android.control.afRegions</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.afState">android.control.afState</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.afTriggerId">android.control.afTriggerId</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.awbMode">android.control.awbMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.awbRegions">android.control.awbRegions</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.awbState">android.control.awbState</a> (dynamic)</li>
-        <li><a href="#dynamic_android.control.mode">android.control.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_demosaic">demosaic</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a> (controls)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_edge">edge</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.edge.mode">android.edge.mode</a> (controls)</li>
-        <li><a href="#controls_android.edge.strength">android.edge.strength</a> (controls)</li>
-        <li><a href="#dynamic_android.edge.mode">android.edge.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_flash">flash</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a> (controls)</li>
-        <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a> (controls)</li>
-        <li><a href="#controls_android.flash.mode">android.flash.mode</a> (controls)</li>
-        <li><a href="#static_android.flash.info.available">android.flash.info.available</a> (static)</li>
-        <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a> (static)</li>
-        <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a> (static)</li>
-        <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a> (static)</li>
-        <li><a href="#dynamic_android.flash.firingPower">android.flash.firingPower</a> (dynamic)</li>
-        <li><a href="#dynamic_android.flash.firingTime">android.flash.firingTime</a> (dynamic)</li>
-        <li><a href="#dynamic_android.flash.mode">android.flash.mode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.flash.state">android.flash.state</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_geometric">geometric</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.geometric.mode">android.geometric.mode</a> (controls)</li>
-        <li><a href="#controls_android.geometric.strength">android.geometric.strength</a> (controls)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_hotPixel">hotPixel</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a> (controls)</li>
-        <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a> (static)</li>
-        <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_jpeg">jpeg</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (controls)</li>
-        <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (controls)</li>
-        <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a> (static)</li>
-        <li><a href="#static_android.jpeg.maxSize">android.jpeg.maxSize</a> (static)</li>
-        <li><a href="#dynamic_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.orientation">android.jpeg.orientation</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.quality">android.jpeg.quality</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.size">android.jpeg.size</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (dynamic)</li>
-        <li><a href="#dynamic_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_lens">lens</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.lens.aperture">android.lens.aperture</a> (controls)</li>
-        <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a> (controls)</li>
-        <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a> (controls)</li>
-        <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
-        <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (controls)</li>
-        <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a> (static)</li>
-        <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a> (static)</li>
-        <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
-        <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a> (static)</li>
-        <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
-        <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a> (static)</li>
-        <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a> (static)</li>
-        <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a> (static)</li>
-        <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
-        <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a> (static)</li>
-        <li><a href="#static_android.lens.facing">android.lens.facing</a> (static)</li>
-        <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a> (static)</li>
-        <li><a href="#static_android.lens.position">android.lens.position</a> (static)</li>
-        <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.lens.state">android.lens.state</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_noiseReduction">noiseReduction</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a> (controls)</li>
-        <li><a href="#controls_android.noiseReduction.strength">android.noiseReduction.strength</a> (controls)</li>
-        <li><a href="#dynamic_android.noiseReduction.mode">android.noiseReduction.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_quirks">quirks</a></p>
-    <ul class="toc_section">
-        <li><a href="#static_android.quirks.meteringCropRegion">android.quirks.meteringCropRegion</a> (static)</li>
-        <li><a href="#static_android.quirks.triggerAfWithAuto">android.quirks.triggerAfWithAuto</a> (static)</li>
-        <li><a href="#static_android.quirks.useZslFormat">android.quirks.useZslFormat</a> (static)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_request">request</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.request.frameCount">android.request.frameCount</a> (controls)</li>
-        <li><a href="#controls_android.request.id">android.request.id</a> (controls)</li>
-        <li><a href="#controls_android.request.inputStreams">android.request.inputStreams</a> (controls)</li>
-        <li><a href="#controls_android.request.metadataMode">android.request.metadataMode</a> (controls)</li>
-        <li><a href="#controls_android.request.outputStreams">android.request.outputStreams</a> (controls)</li>
-        <li><a href="#controls_android.request.type">android.request.type</a> (controls)</li>
-        <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a> (static)</li>
-        <li><a href="#static_android.request.maxNumReprocessStreams">android.request.maxNumReprocessStreams</a> (static)</li>
-        <li><a href="#dynamic_android.request.frameCount">android.request.frameCount</a> (dynamic)</li>
-        <li><a href="#dynamic_android.request.id">android.request.id</a> (dynamic)</li>
-        <li><a href="#dynamic_android.request.metadataMode">android.request.metadataMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.request.outputStreams">android.request.outputStreams</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_scaler">scaler</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a> (controls)</li>
-        <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a> (static)</li>
-        <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a> (static)</li>
-        <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a> (static)</li>
-        <li><a href="#static_android.scaler.availableMaxDigitalZoom">android.scaler.availableMaxDigitalZoom</a> (static)</li>
-        <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a> (static)</li>
-        <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
-        <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
-        <li><a href="#static_android.scaler.availableRawSizes">android.scaler.availableRawSizes</a> (static)</li>
-        <li><a href="#dynamic_android.scaler.cropRegion">android.scaler.cropRegion</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_sensor">sensor</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
-        <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
-        <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
-        <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
-        <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
-        <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
-        <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
-        <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
-        <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
-        <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
-        <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a> (static)</li>
-        <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
-        <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a> (static)</li>
-        <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a> (static)</li>
-        <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a> (static)</li>
-        <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a> (static)</li>
-        <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a> (static)</li>
-        <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a> (static)</li>
-        <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a> (static)</li>
-        <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
-        <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a> (static)</li>
-        <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a> (static)</li>
-        <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
-        <li><a href="#static_android.sensor.referenceIlluminant2">android.sensor.referenceIlluminant2</a> (static)</li>
-        <li><a href="#dynamic_android.sensor.exposureTime">android.sensor.exposureTime</a> (dynamic)</li>
-        <li><a href="#dynamic_android.sensor.frameDuration">android.sensor.frameDuration</a> (dynamic)</li>
-        <li><a href="#dynamic_android.sensor.sensitivity">android.sensor.sensitivity</a> (dynamic)</li>
-        <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_shading">shading</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.shading.mode">android.shading.mode</a> (controls)</li>
-        <li><a href="#controls_android.shading.strength">android.shading.strength</a> (controls)</li>
-        <li><a href="#dynamic_android.shading.mode">android.shading.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_statistics">statistics</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (controls)</li>
-        <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a> (controls)</li>
-        <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (controls)</li>
-        <li><a href="#static_android.statistics.info.availableFaceDetectModes">android.statistics.info.availableFaceDetectModes</a> (static)</li>
-        <li><a href="#static_android.statistics.info.histogramBucketCount">android.statistics.info.histogramBucketCount</a> (static)</li>
-        <li><a href="#static_android.statistics.info.maxFaceCount">android.statistics.info.maxFaceCount</a> (static)</li>
-        <li><a href="#static_android.statistics.info.maxHistogramCount">android.statistics.info.maxHistogramCount</a> (static)</li>
-        <li><a href="#static_android.statistics.info.maxSharpnessMapValue">android.statistics.info.maxSharpnessMapValue</a> (static)</li>
-        <li><a href="#static_android.statistics.info.sharpnessMapSize">android.statistics.info.sharpnessMapSize</a> (static)</li>
-        <li><a href="#dynamic_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.histogramMode">android.statistics.histogramMode</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a> (dynamic)</li>
-        <li><a href="#dynamic_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_tonemap">tonemap</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (controls)</li>
-        <li><a href="#controls_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (controls)</li>
-        <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a> (controls)</li>
-        <li><a href="#controls_android.tonemap.mode">android.tonemap.mode</a> (controls)</li>
-        <li><a href="#static_android.tonemap.maxCurvePoints">android.tonemap.maxCurvePoints</a> (static)</li>
-        <li><a href="#dynamic_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (dynamic)</li>
-        <li><a href="#dynamic_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (dynamic)</li>
-        <li><a href="#dynamic_android.tonemap.curveRed">android.tonemap.curveRed</a> (dynamic)</li>
-        <li><a href="#dynamic_android.tonemap.mode">android.tonemap.mode</a> (dynamic)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_led">led</a></p>
-    <ul class="toc_section">
-        <li><a href="#controls_android.led.transmit">android.led.transmit</a> (controls)</li>
-        <li><a href="#dynamic_android.led.transmit">android.led.transmit</a> (dynamic)</li>
-        <li><a href="#static_android.led.availableLeds">android.led.availableLeds</a> (static)</li>
-    </ul>
-    </li> <!-- toc_section -->
-    <li><p class="toc_section"><a href="#section_info">info</a></p>
-    <ul class="toc_section">
-        <li><a href="#static_android.info.supportedHardwareLevel">android.info.supportedHardwareLevel</a> (static)</li>
-    </ul>
-    </li> <!-- toc_section -->
+    <li><a href="#tag_index" class="toc_section_header">Tags</a></li>
+    <li>
+      <span class="toc_section_header"><a href="#section_colorCorrection">colorCorrection</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.colorCorrection.mode">android.colorCorrection.mode</a></li>
+            <li><a href="#controls_android.colorCorrection.transform">android.colorCorrection.transform</a></li>
+            <li><a href="#controls_android.colorCorrection.gains">android.colorCorrection.gains</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.colorCorrection.transform">android.colorCorrection.transform</a></li>
+            <li><a href="#dynamic_android.colorCorrection.gains">android.colorCorrection.gains</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_control">control</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.control.aeAntibandingMode">android.control.aeAntibandingMode</a></li>
+            <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a></li>
+            <li><a href="#controls_android.control.aeLock">android.control.aeLock</a></li>
+            <li><a href="#controls_android.control.aeMode">android.control.aeMode</a></li>
+            <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a></li>
+            <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a></li>
+            <li><a href="#controls_android.control.aePrecaptureTrigger">android.control.aePrecaptureTrigger</a></li>
+            <li><a href="#controls_android.control.afMode">android.control.afMode</a></li>
+            <li><a href="#controls_android.control.afRegions">android.control.afRegions</a></li>
+            <li><a href="#controls_android.control.afTrigger">android.control.afTrigger</a></li>
+            <li><a href="#controls_android.control.awbLock">android.control.awbLock</a></li>
+            <li><a href="#controls_android.control.awbMode">android.control.awbMode</a></li>
+            <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a></li>
+            <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a></li>
+            <li><a href="#controls_android.control.effectMode">android.control.effectMode</a></li>
+            <li><a href="#controls_android.control.mode">android.control.mode</a></li>
+            <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a></li>
+            <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.control.aeAvailableAntibandingModes">android.control.aeAvailableAntibandingModes</a></li>
+            <li><a href="#static_android.control.aeAvailableModes">android.control.aeAvailableModes</a></li>
+            <li><a href="#static_android.control.aeAvailableTargetFpsRanges">android.control.aeAvailableTargetFpsRanges</a></li>
+            <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a></li>
+            <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a></li>
+            <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a></li>
+            <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a></li>
+            <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a></li>
+            <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a></li>
+            <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a></li>
+            <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a></li>
+            <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.control.aePrecaptureId">android.control.aePrecaptureId</a></li>
+            <li><a href="#dynamic_android.control.aeRegions">android.control.aeRegions</a></li>
+            <li><a href="#dynamic_android.control.aeState">android.control.aeState</a></li>
+            <li><a href="#dynamic_android.control.afMode">android.control.afMode</a></li>
+            <li><a href="#dynamic_android.control.afRegions">android.control.afRegions</a></li>
+            <li><a href="#dynamic_android.control.afState">android.control.afState</a></li>
+            <li><a href="#dynamic_android.control.afTriggerId">android.control.afTriggerId</a></li>
+            <li><a href="#dynamic_android.control.awbMode">android.control.awbMode</a></li>
+            <li><a href="#dynamic_android.control.awbRegions">android.control.awbRegions</a></li>
+            <li><a href="#dynamic_android.control.awbState">android.control.awbState</a></li>
+            <li><a href="#dynamic_android.control.mode">android.control.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_demosaic">demosaic</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_edge">edge</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.edge.mode">android.edge.mode</a></li>
+            <li><a href="#controls_android.edge.strength">android.edge.strength</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.edge.mode">android.edge.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_flash">flash</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a></li>
+            <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a></li>
+            <li><a href="#controls_android.flash.mode">android.flash.mode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+
+            <li><a href="#static_android.flash.info.available">android.flash.info.available</a></li>
+            <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a></li>
+
+            <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a></li>
+            <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.flash.firingPower">android.flash.firingPower</a></li>
+            <li><a href="#dynamic_android.flash.firingTime">android.flash.firingTime</a></li>
+            <li><a href="#dynamic_android.flash.mode">android.flash.mode</a></li>
+            <li><a href="#dynamic_android.flash.state">android.flash.state</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_geometric">geometric</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.geometric.mode">android.geometric.mode</a></li>
+            <li><a href="#controls_android.geometric.strength">android.geometric.strength</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_hotPixel">hotPixel</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+
+            <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a></li>
+
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_jpeg">jpeg</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a></li>
+            <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a></li>
+            <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a></li>
+            <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a></li>
+            <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a></li>
+            <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a></li>
+            <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a></li>
+            <li><a href="#static_android.jpeg.maxSize">android.jpeg.maxSize</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a></li>
+            <li><a href="#dynamic_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a></li>
+            <li><a href="#dynamic_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a></li>
+            <li><a href="#dynamic_android.jpeg.orientation">android.jpeg.orientation</a></li>
+            <li><a href="#dynamic_android.jpeg.quality">android.jpeg.quality</a></li>
+            <li><a href="#dynamic_android.jpeg.size">android.jpeg.size</a></li>
+            <li><a href="#dynamic_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a></li>
+            <li><a href="#dynamic_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_lens">lens</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.lens.aperture">android.lens.aperture</a></li>
+            <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a></li>
+            <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a></li>
+            <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a></li>
+            <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+
+            <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a></li>
+            <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a></li>
+            <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a></li>
+            <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a></li>
+            <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a></li>
+            <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a></li>
+            <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a></li>
+            <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a></li>
+            <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a></li>
+
+            <li><a href="#static_android.lens.facing">android.lens.facing</a></li>
+            <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a></li>
+            <li><a href="#static_android.lens.position">android.lens.position</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a></li>
+            <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a></li>
+            <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a></li>
+            <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a></li>
+            <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a></li>
+            <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a></li>
+            <li><a href="#dynamic_android.lens.state">android.lens.state</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_noiseReduction">noiseReduction</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a></li>
+            <li><a href="#controls_android.noiseReduction.strength">android.noiseReduction.strength</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.noiseReduction.mode">android.noiseReduction.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_quirks">quirks</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.quirks.meteringCropRegion">android.quirks.meteringCropRegion</a></li>
+            <li><a href="#static_android.quirks.triggerAfWithAuto">android.quirks.triggerAfWithAuto</a></li>
+            <li><a href="#static_android.quirks.useZslFormat">android.quirks.useZslFormat</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_request">request</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.request.frameCount">android.request.frameCount</a></li>
+            <li><a href="#controls_android.request.id">android.request.id</a></li>
+            <li><a href="#controls_android.request.inputStreams">android.request.inputStreams</a></li>
+            <li><a href="#controls_android.request.metadataMode">android.request.metadataMode</a></li>
+            <li><a href="#controls_android.request.outputStreams">android.request.outputStreams</a></li>
+            <li><a href="#controls_android.request.type">android.request.type</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a></li>
+            <li><a href="#static_android.request.maxNumReprocessStreams">android.request.maxNumReprocessStreams</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.request.frameCount">android.request.frameCount</a></li>
+            <li><a href="#dynamic_android.request.id">android.request.id</a></li>
+            <li><a href="#dynamic_android.request.metadataMode">android.request.metadataMode</a></li>
+            <li><a href="#dynamic_android.request.outputStreams">android.request.outputStreams</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_scaler">scaler</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a></li>
+            <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a></li>
+            <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a></li>
+            <li><a href="#static_android.scaler.availableMaxDigitalZoom">android.scaler.availableMaxDigitalZoom</a></li>
+            <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a></li>
+            <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a></li>
+            <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a></li>
+            <li><a href="#static_android.scaler.availableRawSizes">android.scaler.availableRawSizes</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.scaler.cropRegion">android.scaler.cropRegion</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_sensor">sensor</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a></li>
+            <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a></li>
+            <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+
+            <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a></li>
+            <li><a href="#static_android.sensor.info.sensitivityRange">android.sensor.info.sensitivityRange</a></li>
+            <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a></li>
+            <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a></li>
+            <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a></li>
+            <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a></li>
+            <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a></li>
+            <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a></li>
+
+            <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a></li>
+            <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a></li>
+            <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a></li>
+            <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a></li>
+            <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a></li>
+            <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a></li>
+            <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a></li>
+            <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a></li>
+            <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a></li>
+            <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a></li>
+            <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a></li>
+            <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a></li>
+            <li><a href="#static_android.sensor.referenceIlluminant2">android.sensor.referenceIlluminant2</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.sensor.exposureTime">android.sensor.exposureTime</a></li>
+            <li><a href="#dynamic_android.sensor.frameDuration">android.sensor.frameDuration</a></li>
+            <li><a href="#dynamic_android.sensor.sensitivity">android.sensor.sensitivity</a></li>
+            <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a></li>
+            <li><a href="#dynamic_android.sensor.temperature">android.sensor.temperature</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_shading">shading</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.shading.mode">android.shading.mode</a></li>
+            <li><a href="#controls_android.shading.strength">android.shading.strength</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.shading.mode">android.shading.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_statistics">statistics</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a></li>
+            <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a></li>
+            <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a></li>
+            <li><a href="#controls_android.statistics.lensShadingMapMode">android.statistics.lensShadingMapMode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+
+            <li><a href="#static_android.statistics.info.availableFaceDetectModes">android.statistics.info.availableFaceDetectModes</a></li>
+            <li><a href="#static_android.statistics.info.histogramBucketCount">android.statistics.info.histogramBucketCount</a></li>
+            <li><a href="#static_android.statistics.info.maxFaceCount">android.statistics.info.maxFaceCount</a></li>
+            <li><a href="#static_android.statistics.info.maxHistogramCount">android.statistics.info.maxHistogramCount</a></li>
+            <li><a href="#static_android.statistics.info.maxSharpnessMapValue">android.statistics.info.maxSharpnessMapValue</a></li>
+            <li><a href="#static_android.statistics.info.sharpnessMapSize">android.statistics.info.sharpnessMapSize</a></li>
+
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a></li>
+            <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a></li>
+            <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a></li>
+            <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a></li>
+            <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a></li>
+            <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a></li>
+            <li><a href="#dynamic_android.statistics.histogramMode">android.statistics.histogramMode</a></li>
+            <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a></li>
+            <li><a href="#dynamic_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a></li>
+            <li><a href="#dynamic_android.statistics.lensShadingMap">android.statistics.lensShadingMap</a></li>
+            <li><a href="#dynamic_android.statistics.predictedColorGains">android.statistics.predictedColorGains</a></li>
+            <li><a href="#dynamic_android.statistics.predictedColorTransform">android.statistics.predictedColorTransform</a></li>
+            <li><a href="#dynamic_android.statistics.sceneFlicker">android.statistics.sceneFlicker</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_tonemap">tonemap</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.tonemap.curveBlue">android.tonemap.curveBlue</a></li>
+            <li><a href="#controls_android.tonemap.curveGreen">android.tonemap.curveGreen</a></li>
+            <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a></li>
+            <li><a href="#controls_android.tonemap.mode">android.tonemap.mode</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.tonemap.maxCurvePoints">android.tonemap.maxCurvePoints</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.tonemap.curveBlue">android.tonemap.curveBlue</a></li>
+            <li><a href="#dynamic_android.tonemap.curveGreen">android.tonemap.curveGreen</a></li>
+            <li><a href="#dynamic_android.tonemap.curveRed">android.tonemap.curveRed</a></li>
+            <li><a href="#dynamic_android.tonemap.mode">android.tonemap.mode</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_led">led</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.led.transmit">android.led.transmit</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.led.transmit">android.led.transmit</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.led.availableLeds">android.led.availableLeds</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_info">info</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">static</span>
+          <ul class="toc_section">
+            <li><a href="#static_android.info.supportedHardwareLevel">android.info.supportedHardwareLevel</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
+    <li>
+      <span class="toc_section_header"><a href="#section_blackLevel">blackLevel</a></span>
+      <ul class="toc_section">
+        <li>
+          <span class="toc_kind_header">controls</span>
+          <ul class="toc_section">
+            <li><a href="#controls_android.blackLevel.lock">android.blackLevel.lock</a></li>
+          </ul>
+        </li>
+        <li>
+          <span class="toc_kind_header">dynamic</span>
+          <ul class="toc_section">
+            <li><a href="#dynamic_android.blackLevel.lock">android.blackLevel.lock</a></li>
+          </ul>
+        </li>
+      </ul> <!-- toc_section -->
+    </li>
   </ul>
 
+
   <h1>Properties</h1>
   <table class="properties">
 
@@ -377,7 +670,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -405,13 +698,13 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
                     <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
                     <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
-              to do color conversion</span>
+              and android.<wbr>color<wbr>Correction.<wbr>gains to do color conversion</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">FAST</span>
@@ -437,6 +730,8 @@
             </td>
 
             <td class="entry_notes">
+              When android.<wbr>control.<wbr>awb<wbr>Mode is not OFF,<wbr> TRANSFORM_<wbr>MATRIX
+          should be ignored.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -448,23 +743,22 @@
           <tr class="entry" id="controls_android.colorCorrection.transform">
             <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>transform</td>
             <td class="entry_type">
-                <span class="entry_type_name">float</span>
+                <span class="entry_type_name">rational</span>
                 <span class="entry_type_container">x</span>
 
                 <span class="entry_type_array">
                   3 x 3
                 </span>
-
-                <div class="entry_type_notes">3x3 float matrix in row-major order</div>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">3x3 rational matrix in row-major order</div>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
-              A transform matrix to chromatically adapt
-          pixels in the CIE XYZ (1931) color space from the scene
-          illuminant to the sRGB-standard
-          D65-illuminant
+              A color transform matrix to use to transform
+          from sensor RGB color space to output linear sRGB color space
+          
             </td>
 
             <td class="entry_units">
@@ -476,10 +770,64 @@
             </td>
 
             <td class="entry_notes">
-              Values outside (0,<wbr>1) should be clamped.<wbr> Need to
-          provide utilities to go from CCT (+hue?),<wbr> or (x,<wbr>y) white
-          point,<wbr> (or AWB mode) to matrix; use linear Bradford
-          algorithm.<wbr>
+              This matrix is either set by HAL when the request
+          android.<wbr>color<wbr>Correction.<wbr>mode is not TRANSFORM_<wbr>MATRIX,<wbr> or
+          directly by the application in the request when the
+          android.<wbr>color<wbr>Correction.<wbr>mode is TRANSFORM_<wbr>MATRIX.<wbr>
+<br>
+<br>          In the latter case,<wbr> the HAL may round the matrix to account
+          for precision issues; the final rounded matrix should be
+          reported back in this matrix result metadata.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.colorCorrection.gains">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>gains</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">A 1D array of floats for 4 color channel gains</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Gains applying to Bayer color channels for
+          white-balance
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              The 4-channel white-balance gains are defined in
+          the order of [R G_<wbr>even G_<wbr>odd B],<wbr> where G_<wbr>even is the gain
+          for green pixels on even rows of the output,<wbr> and G_<wbr>odd
+          is the gain for greenpixels on the odd rows.<wbr> if a HAL
+          does not support a separate gain for even/<wbr>odd green channels,<wbr>
+          it should use the G_<wbr>even value,<wbr>and write G_<wbr>odd equal to
+          G_<wbr>even in the output result metadata.<wbr>
+<br>
+<br>          This array is either set by HAL when the request
+          android.<wbr>color<wbr>Correction.<wbr>mode is not TRANSFORM_<wbr>MATRIX,<wbr> or
+          directly by the application in the request when the
+          android.<wbr>color<wbr>Correction.<wbr>mode is TRANSFORM_<wbr>MATRIX.<wbr>
+<br>
+<br>          The ouput should be the gains actually applied by the HAL to
+          the current frame.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -493,7 +841,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -516,34 +864,70 @@
         
 
                 
-          <tr class="entry" id="dynamic_android.colorCorrection.mode">
-            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>mode</td>
+          <tr class="entry" id="dynamic_android.colorCorrection.transform">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>transform</td>
             <td class="entry_type">
-                <span class="entry_type_name entry_type_name_enum">byte</span>
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
 
+                <span class="entry_type_array">
+                  3 x 3
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">3x3 rational matrix in row-major order</div>
 
 
-                <ul class="entry_type_enum">
-                  <li>
-                    <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
-                    <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
-              to do color conversion</span>
-                  </li>
-                  <li>
-                    <span class="entry_type_enum_name">FAST</span>
-                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
-              bayer output</span>
-                  </li>
-                  <li>
-                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
-                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
-              quality</span>
-                  </li>
-                </ul>
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A color transform matrix to use to transform
+          from sensor RGB color space to output linear sRGB color space
+          
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Output values are expected to be in the range
+          (0,<wbr>1)
+            </td>
+
+            <td class="entry_notes">
+              This matrix is either set by HAL when the request
+          android.<wbr>color<wbr>Correction.<wbr>mode is not TRANSFORM_<wbr>MATRIX,<wbr> or
+          directly by the application in the request when the
+          android.<wbr>color<wbr>Correction.<wbr>mode is TRANSFORM_<wbr>MATRIX.<wbr>
+<br>
+<br>          In the latter case,<wbr> the HAL may round the matrix to account
+          for precision issues; the final rounded matrix should be
+          reported back in this matrix result metadata.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.colorCorrection.gains">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>gains</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">A 1D array of floats for 4 color channel gains</div>
+
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
+              Gains applying to Bayer color channels for
+          white-balance
             </td>
 
             <td class="entry_units">
@@ -553,6 +937,21 @@
             </td>
 
             <td class="entry_notes">
+              The 4-channel white-balance gains are defined in
+          the order of [R G_<wbr>even G_<wbr>odd B],<wbr> where G_<wbr>even is the gain
+          for green pixels on even rows of the output,<wbr> and G_<wbr>odd
+          is the gain for greenpixels on the odd rows.<wbr> if a HAL
+          does not support a separate gain for even/<wbr>odd green channels,<wbr>
+          it should use the G_<wbr>even value,<wbr>and write G_<wbr>odd equal to
+          G_<wbr>even in the output result metadata.<wbr>
+<br>
+<br>          This array is either set by HAL when the request
+          android.<wbr>color<wbr>Correction.<wbr>mode is not TRANSFORM_<wbr>MATRIX,<wbr> or
+          directly by the application in the request when the
+          android.<wbr>color<wbr>Correction.<wbr>mode is TRANSFORM_<wbr>MATRIX.<wbr>
+<br>
+<br>          The ouput should be the gains actually applied by the HAL to
+          the current frame.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -571,7 +970,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -599,7 +998,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -645,7 +1044,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -682,7 +1081,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -731,13 +1130,13 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
                     <span class="entry_type_enum_name">OFF</span>
-                    <span class="entry_type_enum_notes">Autoexposure is disabled; sensor.<wbr>exposureTime
-              and sensor.<wbr>sensitivity are used</span>
+                    <span class="entry_type_enum_notes">Autoexposure is disabled; sensor.<wbr>exposureTime,<wbr>
+              sensor.<wbr>sensitivity and sensor.<wbr>frameDuration are used</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">ON</span>
@@ -804,7 +1203,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -822,18 +1221,21 @@
 
             <td class="entry_notes">
               Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
-          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
-          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
-          active pixel array,<wbr> and
-          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific metering area needs to be used by the HAL.<wbr> If
-          the metering region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific metering area
+          needs to be used by the HAL.<wbr> If the metering region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -854,7 +1256,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -890,7 +1292,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -923,9 +1325,11 @@
               This entry is normally set to IDLE,<wbr> or is not
           included at all in the request settings.<wbr> When included and
           set to START,<wbr> the HAL must trigger the autoexposure
-          precapture metering sequence.<wbr> The effect of AE precapture
-          trigger depends on the current AE mode and state; see the
-          camera HAL device v3 header for details.<wbr>
+          precapture metering sequence.<wbr>
+<br>
+<br>          The effect of AE precapture trigger depends on the current
+          AE mode and state; see the camera HAL device v3 header for
+          details.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -942,75 +1346,82 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
                     <span class="entry_type_enum_name">OFF</span>
                     <span class="entry_type_enum_notes">The 3A routines do not control the lens;
-            android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+            android.<wbr>lens.<wbr>focus<wbr>Distance is controlled by the
             application</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">AUTO</span>
-                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
-            android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
-            is fixed focus In this mode,<wbr> the lens does not move
-            unless the autofocus trigger action is called.<wbr> When
-            that trigger is activated,<wbr> AF must transition to
-            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
-            or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
-            position to default,<wbr> and sets the AF state to
-            INACTIVE.<wbr></span>
+                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr>
+
+            Use android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+            is fixed focus In this mode,<wbr> the lens does not move unless
+            the autofocus trigger action is called.<wbr> When that trigger
+            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then to
+            the outcome of the scan (FOCUSED or
+            NOT_<wbr>FOCUSED).<wbr>
+
+            Triggering cancel AF resets the lens position to default,<wbr>
+            and sets the AF state to INACTIVE.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">MACRO</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
-            autofocus trigger action is called.<wbr> When that trigger
-            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
-            to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
-            Triggering cancel AF resets the lens position to
-            default,<wbr> and sets the AF state to
+            autofocus trigger action is called.<wbr>
+
+            When that trigger is activated,<wbr> AF must transition to
+            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED or
+            NOT_<wbr>FOCUSED).<wbr>  Triggering cancel AF resets the lens
+            position to default,<wbr> and sets the AF state to
             INACTIVE.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream.<wbr> The focusing behavior
-            should be suitable for good quality video recording;
-            typically this means slower focus movement and no
-            overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
-            algorithm should start in INACTIVE state,<wbr> and then
-            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
-            as appropriate.<wbr> When the AF trigger is activated,<wbr> the
-            algorithm should immediately transition into AF_<wbr>FOCUSED
-            or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
-            position until a cancel AF trigger is received.<wbr> Once
-            cancel is received,<wbr> the algorithm should transition
-            back to INACTIVE and resume passive scan.<wbr> Note that
-            this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
-            since an ongoing PASSIVE_<wbr>SCAN must immediately be
+            constantly-in-focus image stream.<wbr>
+
+            The focusing behavior should be suitable for good quality
+            video recording; typically this means slower focus
+            movement and no overshoots.<wbr> When the AF trigger is not
+            involved,<wbr> the AF algorithm should start in INACTIVE state,<wbr>
+            and then transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED
+            states as appropriate.<wbr> When the AF trigger is activated,<wbr>
+            the algorithm should immediately transition into
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the
+            lens position until a cancel AF trigger is received.<wbr>
+
+            Once cancel is received,<wbr> the algorithm should transition
+            back to INACTIVE and resume passive scan.<wbr> Note that this
+            behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr> since an
+            ongoing PASSIVE_<wbr>SCAN must immediately be
             canceled.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream.<wbr> The focusing behavior
-            should be suitable for still image capture; typically
-            this means focusing as fast as possible.<wbr> When the AF
-            trigger is not involved,<wbr> the AF algorithm should start
-            in INACTIVE state,<wbr> and then transition into
-            PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
-            as it attempts to maintain focus.<wbr> When the AF trigger
-            is activated,<wbr> the algorithm should finish its
+            constantly-in-focus image stream.<wbr>
+
+            The focusing behavior should be suitable for still image
+            capture; typically this means focusing as fast as
+            possible.<wbr> When the AF trigger is not involved,<wbr> the AF
+            algorithm should start in INACTIVE state,<wbr> and then
+            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as
+            appropriate as it attempts to maintain focus.<wbr> When the AF
+            trigger is activated,<wbr> the algorithm should finish its
             PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
-            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
-            the lens position until a cancel AF trigger is
-            received.<wbr> When the AF cancel trigger is activated,<wbr> the
-            algorithm should transition back to INACTIVE and then
-            act as if it has just been started.<wbr></span>
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the
+            lens position until a cancel AF trigger is received.<wbr>
+
+            When the AF cancel trigger is activated,<wbr> the algorithm
+            should transition back to INACTIVE and then act as if it
+            has just been started.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">EDOF</span>
@@ -1054,7 +1465,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -1072,18 +1483,21 @@
 
             <td class="entry_notes">
               Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
-          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
-          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
-          active pixel array,<wbr> and
-          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific focus area needs to be used by the HAL.<wbr> If
-          the focusing region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific focus area
+          needs to be used by the HAL.<wbr> If the focusing region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -1100,7 +1514,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1132,12 +1546,13 @@
 
             <td class="entry_notes">
               This entry is normally set to IDLE,<wbr> or is not
-          included at all in the request settings.<wbr> When included and
-          set to START,<wbr> the HAL must trigger the autofocus
-          algorithm.<wbr> The effect of AF trigger depends on the current
-          AF mode and state; see the camera HAL device v3 header for
-          details.<wbr> When set to CANCEL,<wbr> the HAL must cancel any active
-          trigger,<wbr> and return to initial AF state.<wbr>
+          included at all in the request settings.<wbr>
+<br>
+<br>          When included and set to START,<wbr> the HAL must trigger the
+          autofocus algorithm.<wbr> The effect of AF trigger depends on the
+          current AF mode and state; see the camera HAL device v3
+          header for details.<wbr> When set to CANCEL,<wbr> the HAL must cancel
+          any active trigger,<wbr> and return to initial AF state.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -1154,7 +1569,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1204,7 +1619,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1273,7 +1688,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -1290,19 +1705,24 @@
             </td>
 
             <td class="entry_notes">
-              Only used in AUTO mode.<wbr> Each area is a rectangle
-          plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
-          coordinate system is based on the active pixel array,<wbr>
-          with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
-          and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific metering area needs to be used by the HAL.<wbr> If
-          the metering region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+              Only used in AUTO mode.<wbr>
+<br>
+<br>          Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific metering area
+          needs to be used by the HAL.<wbr> If the metering region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -1319,7 +1739,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1391,7 +1811,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1462,7 +1882,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1521,7 +1941,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1534,10 +1954,12 @@
             detection data to drive 3A routines.<wbr> If face detection
             statistics are disabled,<wbr> should still operate correctly
             (but not return face detection statistics to the
-            framework).<wbr> Unlike the other scene modes,<wbr> aeMode,<wbr>
-            awbMode,<wbr> and afMode remain active when FACE_<wbr>PRIORITY is
-            set.<wbr> This is due to compatibility concerns with the old
-            camera API</span>
+            framework).<wbr>
+
+            Unlike the other scene modes,<wbr> aeMode,<wbr> awbMode,<wbr> and afMode
+            remain active when FACE_<wbr>PRIORITY is set.<wbr> This is due to
+            compatibility concerns with the old camera
+            API</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">ACTION</span>
@@ -1632,7 +2054,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -1676,7 +2098,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -1708,7 +2130,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">list of enums</div>
 
 
@@ -1743,7 +2165,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">list of enums</div>
 
 
@@ -1781,7 +2203,7 @@
                 <span class="entry_type_array">
                   2 x n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">list of pairs of frame rates</div>
 
 
@@ -1816,7 +2238,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -1852,7 +2274,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">rational</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -1890,7 +2312,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">List of enums</div>
 
 
@@ -1930,7 +2352,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">list of enums</div>
 
 
@@ -1969,7 +2391,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">list of enums from android.<wbr>control.<wbr>scene<wbr>Mode,<wbr> plus UNSUPPORTED to indicate no scene modes are supported</div>
 
 
@@ -2009,7 +2431,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">List of enums.<wbr></div>
 
 
@@ -2048,7 +2470,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">List of enums (android.<wbr>control.<wbr>awb<wbr>Mode)</div>
 
 
@@ -2081,7 +2503,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -2117,9 +2539,9 @@
                 <span class="entry_type_container">x</span>
 
                 <span class="entry_type_array">
-                  3 x lengthavailablescenemodes
+                  3 x length(availableSceneModes)
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -2135,28 +2557,32 @@
             <td class="entry_range">
               For each listed scene mode,<wbr> lists the aeMode,<wbr>
           awbMode,<wbr> and afMode that the HAL wants to use for that
-          scene mode.<wbr> For each entry,<wbr> the order is {aeMode,<wbr>
-          awbMode,<wbr> afMode} in order of increasing index
+          scene mode.<wbr>
+
+          For each entry,<wbr> the order is {aeMode,<wbr> awbMode,<wbr> afMode} in
+          order of increasing index
             </td>
 
             <td class="entry_notes">
               When a scene mode is enabled,<wbr> the HAL is expected
           to override aeMode,<wbr> awbMode,<wbr> and afMode with its
-          preferred settings for that scene mode.<wbr> To simplify
-          communication with old camera API applications,<wbr> the
-          service wants this override list in the static metadata.<wbr>
-          The order of this list matches that of
-          availableSceneModes,<wbr> with 3 entires for each scene mode.<wbr>
-          The overrides listed for SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY are
-          ignored,<wbr> since for that mode,<wbr> the application-set aeMode,<wbr>
-          awbMode,<wbr> and afMode are used instead,<wbr> like they are when
-          android.<wbr>control.<wbr>mode is AUTO.<wbr> It is recommended that for
-          FACE_<wbr>PRIORITY,<wbr> the overrides should be set to 0.<wbr> As an
-          example,<wbr> if availableSceneModes is { FACE_<wbr>PRIORITY,<wbr>
-          ACTION,<wbr> NIGHT },<wbr> then the service expects this field to
-          have 9 entries; for example { 0 ,<wbr> 0,<wbr> 0,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr>
-          AUTO,<wbr> CONTINUOUS_<wbr>PICTURE,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr> INCANDESCENT,<wbr>
-          AUTO }
+          preferred settings for that scene mode.<wbr>
+<br>
+<br>          To simplify communication with old camera API applications,<wbr>
+          the service wants this override list in the static metadata.<wbr>
+          The order of this list matches that of availableSceneModes,<wbr>
+          with 3 entires for each scene mode.<wbr>  The overrides listed
+          for SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY are ignored,<wbr> since for that
+          mode,<wbr> the application-set aeMode,<wbr> awbMode,<wbr> and afMode are
+          used instead,<wbr> like they are when android.<wbr>control.<wbr>mode is
+          AUTO.<wbr>
+<br>
+<br>          It is recommended that for FACE_<wbr>PRIORITY,<wbr> the overrides
+          should be set to 0.<wbr> As an example,<wbr> if availableSceneModes is
+          { FACE_<wbr>PRIORITY,<wbr> ACTION,<wbr> NIGHT },<wbr> then the service expects
+          this field to have 9 entries; for example { 0 ,<wbr> 0,<wbr> 0,<wbr>
+          ON_<wbr>AUTO_<wbr>FLASH,<wbr> AUTO,<wbr> CONTINUOUS_<wbr>PICTURE,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr>
+          INCANDESCENT,<wbr> AUTO }
             </td>
 
             <td class="entry_tags">
@@ -2173,7 +2599,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -2201,7 +2627,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [hidden]</span>
 
 
             </td> <!-- entry_type -->
@@ -2239,7 +2665,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -2257,18 +2683,21 @@
 
             <td class="entry_notes">
               Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
-          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
-          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
-          active pixel array,<wbr> and
-          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific metering area needs to be used by the HAL.<wbr> If
-          the metering region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific metering area
+          needs to be used by the HAL.<wbr> If the metering region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -2285,7 +2714,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2354,75 +2783,82 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
                     <span class="entry_type_enum_name">OFF</span>
                     <span class="entry_type_enum_notes">The 3A routines do not control the lens;
-            android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+            android.<wbr>lens.<wbr>focus<wbr>Distance is controlled by the
             application</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">AUTO</span>
-                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
-            android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
-            is fixed focus In this mode,<wbr> the lens does not move
-            unless the autofocus trigger action is called.<wbr> When
-            that trigger is activated,<wbr> AF must transition to
-            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
-            or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
-            position to default,<wbr> and sets the AF state to
-            INACTIVE.<wbr></span>
+                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr>
+
+            Use android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+            is fixed focus In this mode,<wbr> the lens does not move unless
+            the autofocus trigger action is called.<wbr> When that trigger
+            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then to
+            the outcome of the scan (FOCUSED or
+            NOT_<wbr>FOCUSED).<wbr>
+
+            Triggering cancel AF resets the lens position to default,<wbr>
+            and sets the AF state to INACTIVE.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">MACRO</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
-            autofocus trigger action is called.<wbr> When that trigger
-            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
-            to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
-            Triggering cancel AF resets the lens position to
-            default,<wbr> and sets the AF state to
+            autofocus trigger action is called.<wbr>
+
+            When that trigger is activated,<wbr> AF must transition to
+            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED or
+            NOT_<wbr>FOCUSED).<wbr>  Triggering cancel AF resets the lens
+            position to default,<wbr> and sets the AF state to
             INACTIVE.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream.<wbr> The focusing behavior
-            should be suitable for good quality video recording;
-            typically this means slower focus movement and no
-            overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
-            algorithm should start in INACTIVE state,<wbr> and then
-            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
-            as appropriate.<wbr> When the AF trigger is activated,<wbr> the
-            algorithm should immediately transition into AF_<wbr>FOCUSED
-            or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
-            position until a cancel AF trigger is received.<wbr> Once
-            cancel is received,<wbr> the algorithm should transition
-            back to INACTIVE and resume passive scan.<wbr> Note that
-            this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
-            since an ongoing PASSIVE_<wbr>SCAN must immediately be
+            constantly-in-focus image stream.<wbr>
+
+            The focusing behavior should be suitable for good quality
+            video recording; typically this means slower focus
+            movement and no overshoots.<wbr> When the AF trigger is not
+            involved,<wbr> the AF algorithm should start in INACTIVE state,<wbr>
+            and then transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED
+            states as appropriate.<wbr> When the AF trigger is activated,<wbr>
+            the algorithm should immediately transition into
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the
+            lens position until a cancel AF trigger is received.<wbr>
+
+            Once cancel is received,<wbr> the algorithm should transition
+            back to INACTIVE and resume passive scan.<wbr> Note that this
+            behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr> since an
+            ongoing PASSIVE_<wbr>SCAN must immediately be
             canceled.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
                     <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream.<wbr> The focusing behavior
-            should be suitable for still image capture; typically
-            this means focusing as fast as possible.<wbr> When the AF
-            trigger is not involved,<wbr> the AF algorithm should start
-            in INACTIVE state,<wbr> and then transition into
-            PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
-            as it attempts to maintain focus.<wbr> When the AF trigger
-            is activated,<wbr> the algorithm should finish its
+            constantly-in-focus image stream.<wbr>
+
+            The focusing behavior should be suitable for still image
+            capture; typically this means focusing as fast as
+            possible.<wbr> When the AF trigger is not involved,<wbr> the AF
+            algorithm should start in INACTIVE state,<wbr> and then
+            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as
+            appropriate as it attempts to maintain focus.<wbr> When the AF
+            trigger is activated,<wbr> the algorithm should finish its
             PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
-            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
-            the lens position until a cancel AF trigger is
-            received.<wbr> When the AF cancel trigger is activated,<wbr> the
-            algorithm should transition back to INACTIVE and then
-            act as if it has just been started.<wbr></span>
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the
+            lens position until a cancel AF trigger is received.<wbr>
+
+            When the AF cancel trigger is activated,<wbr> the algorithm
+            should transition back to INACTIVE and then act as if it
+            has just been started.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">EDOF</span>
@@ -2466,7 +2902,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -2484,18 +2920,21 @@
 
             <td class="entry_notes">
               Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
-          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
-          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
-          active pixel array,<wbr> and
-          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific focus area needs to be used by the HAL.<wbr> If
-          the focusing region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific focus area
+          needs to be used by the HAL.<wbr> If the focusing region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -2512,7 +2951,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2523,34 +2962,40 @@
                   </li>
                   <li>
                     <span class="entry_type_enum_name">PASSIVE_SCAN</span>
-                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF is
+                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported.<wbr> AF is
             currently doing an AF scan initiated by a continuous
             autofocus mode</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">PASSIVE_FOCUSED</span>
-                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF currently
+                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported.<wbr> AF currently
             believes it is in focus,<wbr> but may restart scanning at
             any time.<wbr></span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">ACTIVE_SCAN</span>
-                    <span class="entry_type_enum_notes">if AUTO or MACRO modes are supported AF is doing
+                    <span class="entry_type_enum_notes">if AUTO or MACRO modes are supported.<wbr> AF is doing
             an AF scan because it was triggered by AF
             trigger</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">FOCUSED_LOCKED</span>
-                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF
+                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported.<wbr> AF
             believes it is focused correctly and is
             locked</span>
                   </li>
                   <li>
                     <span class="entry_type_enum_name">NOT_FOCUSED_LOCKED</span>
-                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF has
+                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported.<wbr> AF has
             failed to focus successfully and is
             locked</span>
                   </li>
+                  <li>
+                    <span class="entry_type_enum_name">PASSIVE_UNFOCUSED</span>
+                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported.<wbr> AF finished a
+            passive scan without finding focus,<wbr> and may restart
+            scanning at any time.<wbr></span>
+                  </li>
                 </ul>
 
             </td> <!-- entry_type -->
@@ -2582,7 +3027,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [hidden]</span>
 
 
             </td> <!-- entry_type -->
@@ -2615,7 +3060,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2684,7 +3129,7 @@
                 <span class="entry_type_array">
                   5 x area_count
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -2701,19 +3146,24 @@
             </td>
 
             <td class="entry_notes">
-              Only used in AUTO mode.<wbr> Each area is a rectangle
-          plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
-          coordinate system is based on the active pixel array,<wbr>
-          with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
-          and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
-          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
-          bottom-right point of the active pixel array.<wbr> The weight
-          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
-          no specific metering area needs to be used by the HAL.<wbr> If
-          the metering region is outside the current
-          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata
+              Only used in AUTO mode.<wbr>
+<br>
+<br>          Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The rectangle is defined inclusive of the
+          specified coordinates.<wbr>
+<br>
+<br>          The coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left pixel in the active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width - 1,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height - 1) being the
+          bottom-right pixel in the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr>
+<br>
+<br>          If all regions have 0 weight,<wbr> then no specific metering area
+          needs to be used by the HAL.<wbr> If the metering region is
+          outside the current android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata
             </td>
 
             <td class="entry_tags">
@@ -2730,7 +3180,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2784,7 +3234,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2848,7 +3298,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -2876,7 +3326,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -2926,7 +3376,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -2954,7 +3404,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3000,7 +3450,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3031,7 +3481,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3059,7 +3509,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3110,7 +3560,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3138,7 +3588,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3175,7 +3625,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3212,7 +3662,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3263,7 +3713,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3293,7 +3743,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -3329,7 +3779,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3369,7 +3819,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3404,7 +3854,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3439,7 +3889,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3467,7 +3917,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3504,7 +3954,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3541,7 +3991,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3592,7 +4042,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3648,7 +4098,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3676,7 +4126,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3723,7 +4173,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -3763,7 +4213,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3791,7 +4241,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3841,7 +4291,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3875,7 +4325,7 @@
                 <span class="entry_type_array">
                   2 x n
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">list of coordinates based on android.<wbr>sensor.<wbr>pixel<wbr>Array<wbr>Size</div>
 
 
@@ -3912,7 +4362,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -3940,7 +4390,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -3995,7 +4445,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -4027,7 +4477,7 @@
                 <span class="entry_type_array">
                   3
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
 
 
@@ -4062,7 +4512,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public as string]</span>
 
 
             </td> <!-- entry_type -->
@@ -4096,7 +4546,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4130,7 +4580,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4165,7 +4615,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4200,7 +4650,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4238,7 +4688,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -4272,7 +4722,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -4304,7 +4754,7 @@
                 <span class="entry_type_array">
                   2 x n
                 </span>
-
+              <span class="entry_type_visibility"> [public as size]</span>
                 <div class="entry_type_notes">list of resolution pairs</div>
 
 
@@ -4340,7 +4790,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -4374,7 +4824,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -4406,7 +4856,7 @@
                 <span class="entry_type_array">
                   3
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
 
 
@@ -4441,7 +4891,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public as string]</span>
 
 
             </td> <!-- entry_type -->
@@ -4475,7 +4925,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4509,7 +4959,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4544,7 +4994,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4579,7 +5029,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -4598,13 +5048,14 @@
 
             <td class="entry_notes">
               If no JPEG output is produced for the request,<wbr>
-          this must be 0.<wbr> Otherwise,<wbr> this describes the real size
-          of the compressed JPEG image placed in the output stream.<wbr>
-          More specifically,<wbr> if android.<wbr>jpeg.<wbr>max<wbr>Size = 1000000,<wbr> and
-          a specific capture has android.<wbr>jpeg.<wbr>size = 500000,<wbr> then
-          the output buffer from the JPEG stream will be 1000000
-          bytes,<wbr> of which the first 500000 make up the real
-          data.<wbr>
+          this must be 0.<wbr>
+<br>
+<br>          Otherwise,<wbr> this describes the real size of the compressed
+          JPEG image placed in the output stream.<wbr>  More specifically,<wbr>
+          if android.<wbr>jpeg.<wbr>max<wbr>Size = 1000000,<wbr> and a specific capture
+          has android.<wbr>jpeg.<wbr>size = 500000,<wbr> then the output buffer from
+          the JPEG stream will be 1000000 bytes,<wbr> of which the first
+          500000 make up the real data.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -4618,7 +5069,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4656,7 +5107,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -4695,7 +5146,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -4723,7 +5174,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4759,7 +5210,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4796,7 +5247,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4831,7 +5282,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4869,7 +5320,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -4913,7 +5364,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -4947,7 +5398,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -4987,7 +5438,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5029,7 +5480,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">the list of available focal lengths</div>
 
 
@@ -5072,7 +5523,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">list of enums</div>
 
 
@@ -5110,7 +5561,7 @@
                 <span class="entry_type_array">
                   2 x 3 x n x m
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">2D array of destination coordinate pairs for uniform grid points in source image,<wbr> per color channel.<wbr> Size in the range of 2x3x40x30</div>
 
 
@@ -5155,7 +5606,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [system as size]</span>
                 <div class="entry_type_notes">width and height of geometric correction map</div>
 
 
@@ -5190,7 +5641,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5227,7 +5678,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5259,49 +5710,6 @@
           </tr> <!-- end of entry -->
         
                 
-          <tr class="entry" id="static_android.lens.info.shadingMap">
-            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map</td>
-            <td class="entry_type">
-                <span class="entry_type_name">float</span>
-                <span class="entry_type_container">x</span>
-
-                <span class="entry_type_array">
-                  3 x n x m
-                </span>
-
-                <div class="entry_type_notes">2D array of float gain factors per channel to correct for lens falloff.<wbr> Should be on the order of 3x40x30</div>
-
-
-            </td> <!-- entry_type -->
-
-            <td class="entry_description">
-              A low-resolution map of lens shading,<wbr> per
-            color channel
-            </td>
-
-            <td class="entry_units">
-            </td>
-
-            <td class="entry_range">
-              Each gain factor is >= 1
-            </td>
-
-            <td class="entry_notes">
-              Assume bilinear interpolation of map.<wbr> The least
-            shaded section of the image should have a gain factor
-            of 1; all other sections should have gains above
-            1.<wbr>
-            </td>
-
-            <td class="entry_tags">
-              <ul class="entry_tags">
-                  <li><a href="#tag_DNG">DNG</a></li>
-              </ul>
-            </td>
-
-          </tr> <!-- end of entry -->
-        
-                
           <tr class="entry" id="static_android.lens.info.shadingMapSize">
             <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map<wbr>Size</td>
             <td class="entry_type">
@@ -5311,8 +5719,8 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
-                <div class="entry_type_notes">width and height of lens shading map</div>
+              <span class="entry_type_visibility"> [public as size]</span>
+                <div class="entry_type_notes">width and height of lens shading map provided by the HAL.<wbr> (N,<wbr> M)</div>
 
 
             </td> <!-- entry_type -->
@@ -5349,7 +5757,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -5391,7 +5799,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">degrees.<wbr> First defines the angle of separation between the perpendicular to the screen and the camera optical axis.<wbr> The second then defines the clockwise rotation of the optical axis from native device up.<wbr></div>
 
 
@@ -5410,12 +5818,18 @@
             </td>
 
             <td class="entry_notes">
-              Examples: (0,<wbr>0) means that the camera optical axis
-          is perpendicular to the display surface; (45,<wbr>0) means
-          that the camera points 45 degrees up when device is held
-          upright; (45,<wbr>90) means the camera points 45 degrees to
-          the right when the device is held upright.<wbr> Use FACING
-          field to determine perpendicular outgoing
+              Examples:
+<br>
+<br>          (0,<wbr>0) means that the camera optical axis
+          is perpendicular to the display surface;
+<br>
+<br>          (45,<wbr>0) means that the camera points 45 degrees up when
+          device is held upright;
+<br>
+<br>          (45,<wbr>90) means the camera points 45 degrees to the right when
+          the device is held upright.<wbr>
+<br>
+<br>          Use FACING field to determine perpendicular outgoing
           direction
             </td>
 
@@ -5438,7 +5852,7 @@
                   3, location in mm, in the sensor coordinate
             system
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -5471,7 +5885,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -5499,7 +5913,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5535,7 +5949,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5572,7 +5986,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5607,7 +6021,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -5642,8 +6056,13 @@
             <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Range</td>
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
 
-
+                <span class="entry_type_array">
+                  2
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">Range of scene distances that are in focus</div>
 
 
             </td> <!-- entry_type -->
@@ -5681,7 +6100,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -5725,12 +6144,15 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
                     <span class="entry_type_enum_name">STATIONARY</span>
                   </li>
+                  <li>
+                    <span class="entry_type_enum_name">MOVING</span>
+                  </li>
                 </ul>
 
             </td> <!-- entry_type -->
@@ -5767,7 +6189,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -5795,7 +6217,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -5845,7 +6267,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -5877,7 +6299,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -5905,7 +6327,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -5960,7 +6382,7 @@
 
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -5988,7 +6410,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6009,11 +6431,12 @@
             <td class="entry_notes">
               Normalized coordinates refer to those in the
           (-1000,<wbr>1000) range mentioned in the
-          android.<wbr>hardware.<wbr><wbr>Camera API.<wbr> HAL implementations should
-          instead always use and emit sensor array-relative
-          coordinates for all region data.<wbr> Does not need to be
-          listed in static metadata.<wbr> Support will be removed in
-          future versions of camera service.<wbr>
+          android.<wbr>hardware.<wbr><wbr>Camera API.<wbr>
+<br>
+<br>          HAL implementations should instead always use and emit
+          sensor array-relative coordinates for all region data.<wbr> Does
+          not need to be listed in static metadata.<wbr> Support will be
+          removed in future versions of camera service.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -6027,7 +6450,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6063,7 +6486,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6106,7 +6529,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -6134,14 +6557,17 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
               A frame counter set by the framework.<wbr> Must
-          be maintained unchanged in output frame
+          be maintained unchanged in output frame.<wbr> This value monotonically
+          increases with every new result (that is,<wbr> each new result has a unique
+          frameCount value).<wbr>
+          
             </td>
 
             <td class="entry_units">
@@ -6166,7 +6592,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [hidden]</span>
 
 
             </td> <!-- entry_type -->
@@ -6200,9 +6626,13 @@
           <tr class="entry" id="controls_android.request.inputStreams">
             <td class="entry_name">android.<wbr>request.<wbr>input<wbr>Streams</td>
             <td class="entry_type">
-                <span class="entry_type_name">byte</span>
-
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
 
+                <span class="entry_type_array">
+                  n
+                </span>
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6218,10 +6648,11 @@
 
             <td class="entry_range">
               Typically,<wbr> only one entry allowed,<wbr> must be a valid
-          reprocess stream ID.<wbr> If android.<wbr>jpeg.<wbr>needs<wbr>Thumbnail is
-          set,<wbr> then multiple reprocess streams may be included in a
-          single request; they must be different scaled versions of
-          the same image.<wbr>
+          reprocess stream ID.<wbr>
+
+          If android.<wbr>jpeg.<wbr>needs<wbr>Thumbnail is set,<wbr> then multiple
+          reprocess streams may be included in a single request; they
+          must be different scaled versions of the same image.<wbr>
             </td>
 
             <td class="entry_notes">
@@ -6230,6 +6661,9 @@
             </td>
 
             <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
             </td>
 
           </tr> <!-- end of entry -->
@@ -6240,7 +6674,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -6287,9 +6721,13 @@
           <tr class="entry" id="controls_android.request.outputStreams">
             <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
             <td class="entry_type">
-                <span class="entry_type_name">byte</span>
-
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
 
+                <span class="entry_type_array">
+                  n
+                </span>
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6316,6 +6754,9 @@
             </td>
 
             <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
             </td>
 
           </tr> <!-- end of entry -->
@@ -6326,7 +6767,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -6348,7 +6789,7 @@
 
             <td class="entry_description">
               The type of the request; either CAPTURE or
-          REPROCESS
+          REPROCESS.<wbr> For HAL3,<wbr> this tag is redundant.<wbr>
             </td>
 
             <td class="entry_units">
@@ -6361,6 +6802,9 @@
             </td>
 
             <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
             </td>
 
           </tr> <!-- end of entry -->
@@ -6371,7 +6815,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -6403,7 +6847,7 @@
                 <span class="entry_type_array">
                   3
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -6448,7 +6892,7 @@
                 <span class="entry_type_array">
                   1
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6479,7 +6923,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -6507,14 +6951,15 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
-              Number of frames captured since
-          open()
+              A frame counter set by the framework.<wbr> This value monotonically
+          increases with every new result (that is,<wbr> each new result has a unique
+          frameCount value).<wbr>
             </td>
 
             <td class="entry_units">
@@ -6540,7 +6985,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [hidden]</span>
 
 
             </td> <!-- entry_type -->
@@ -6576,7 +7021,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -6623,9 +7068,13 @@
           <tr class="entry" id="dynamic_android.request.outputStreams">
             <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
             <td class="entry_type">
-                <span class="entry_type_name">byte</span>
-
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
 
+                <span class="entry_type_array">
+                  n
+                </span>
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -6652,6 +7101,9 @@
             </td>
 
             <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
             </td>
 
           </tr> <!-- end of entry -->
@@ -6667,7 +7119,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -6699,7 +7151,7 @@
                 <span class="entry_type_array">
                   4
                 </span>
-
+              <span class="entry_type_visibility"> [public as rectangle]</span>
 
 
             </td> <!-- entry_type -->
@@ -6769,7 +7221,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -6801,7 +7253,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public as imageFormat]</span>
                 <div class="entry_type_notes">values from HAL_<wbr>PIXEL_<wbr>FORMAT_<wbr>* in /<wbr>system/<wbr>core/<wbr>include/<wbr>system/<wbr>graphics.<wbr>h</div>
 
                 <ul class="entry_type_enum">
@@ -6869,7 +7321,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -6878,8 +7330,8 @@
               The minimum frame duration that is supported
           for each resolution in availableJpegSizes.<wbr> Should
           correspond to the frame duration when only that JPEG
-          stream is active,<wbr> with all processing set to
-          FAST
+          stream is active and captured in a burst,<wbr> with all
+          processing set to FAST
             </td>
 
             <td class="entry_units">
@@ -6912,7 +7364,7 @@
                 <span class="entry_type_array">
                   n x 2
                 </span>
-
+              <span class="entry_type_visibility"> [public as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -6947,7 +7399,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -6987,7 +7439,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -7030,7 +7482,7 @@
                 <span class="entry_type_array">
                   n x 2
                 </span>
-
+              <span class="entry_type_visibility"> [public as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -7052,6 +7504,13 @@
             </td>
 
             <td class="entry_notes">
+              The actual supported resolution list may be limited by
+          consumer end points for different use cases.<wbr> For example,<wbr> for
+          recording use case,<wbr> the largest supported resolution may be
+          limited by max supported size from encoder,<wbr> for preview use
+          case,<wbr> the largest supported resolution may be limited by max
+          resolution SurfaceTexture/<wbr>SurfaceView can support.<wbr>
+          
             </td>
 
             <td class="entry_tags">
@@ -7072,7 +7531,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -7114,7 +7573,7 @@
                 <span class="entry_type_array">
                   n x 2
                 </span>
-
+              <span class="entry_type_visibility"> [system as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -7146,7 +7605,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -7178,7 +7637,7 @@
                 <span class="entry_type_array">
                   4
                 </span>
-
+              <span class="entry_type_visibility"> [public as rectangle]</span>
 
 
             </td> <!-- entry_type -->
@@ -7253,7 +7712,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -7281,14 +7740,18 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
               Duration each pixel is exposed to
-          light
+          light.<wbr>
+<br>
+<br>          If the sensor can't expose this exact duration,<wbr> it should shorten the
+          duration exposed to the nearest possible value (rather than expose longer).<wbr>
+          
             </td>
 
             <td class="entry_units">
@@ -7317,7 +7780,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -7356,7 +7819,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -7365,6 +7828,10 @@
               Gain applied to image data.<wbr> Must be
           implemented through analog gain only if set to values
           below 'maximum analog sensitivity'.<wbr>
+<br>
+<br>          If the sensor can't apply this exact gain,<wbr> it should lessen the
+          gain to the nearest possible value (rather than gain more).<wbr>
+          
             </td>
 
             <td class="entry_units">
@@ -7393,7 +7860,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -7427,7 +7894,7 @@
                 <span class="entry_type_array">
                   4
                 </span>
-
+              <span class="entry_type_visibility"> [public as rectangle]</span>
                 <div class="entry_type_notes">Four ints defining the active pixel rectangle</div>
 
 
@@ -7459,17 +7926,17 @@
           </tr> <!-- end of entry -->
         
                 
-          <tr class="entry" id="static_android.sensor.info.availableSensitivities">
-            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>available<wbr>Sensitivities</td>
+          <tr class="entry" id="static_android.sensor.info.sensitivityRange">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>sensitivity<wbr>Range</td>
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
                 <span class="entry_type_container">x</span>
 
                 <span class="entry_type_array">
-                  n
+                  2
                 </span>
-
-                <div class="entry_type_notes">List of supported sensitivity values</div>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">Range of supported sensitivities</div>
 
 
             </td> <!-- entry_type -->
@@ -7482,8 +7949,7 @@
             </td>
 
             <td class="entry_range">
-              Must at least include 100,<wbr> 200,<wbr> 400,<wbr> 800,<wbr>
-            1600
+              Min <= 100,<wbr> Max >= 1600
             </td>
 
             <td class="entry_notes">
@@ -7504,7 +7970,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -7562,7 +8028,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">nanoseconds</div>
 
 
@@ -7598,13 +8064,13 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
-              Maximum frame duration (minimum frame
+              Maximum possible frame duration (minimum frame
             rate)
             </td>
 
@@ -7619,7 +8085,9 @@
             <td class="entry_notes">
               Minimum duration is a function of resolution,<wbr>
             processing settings.<wbr> See
-            android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+            android.<wbr>scaler.<wbr>available<wbr>Processed<wbr>Min<wbr>Durations
+            android.<wbr>scaler.<wbr>available<wbr>Jpeg<wbr>Min<wbr>Durations
+            android.<wbr>scaler.<wbr>available<wbr>Raw<wbr>Min<wbr>Durations
             </td>
 
             <td class="entry_tags">
@@ -7641,7 +8109,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">width x height in millimeters</div>
 
 
@@ -7681,7 +8149,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [system as size]</span>
 
 
             </td> <!-- entry_type -->
@@ -7718,7 +8186,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -7757,7 +8225,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">rational</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -7779,6 +8247,7 @@
             <td class="entry_tags">
               <ul class="entry_tags">
                   <li><a href="#tag_V1">V1</a></li>
+                  <li><a href="#tag_FULL">FULL</a></li>
               </ul>
             </td>
 
@@ -7794,7 +8263,7 @@
                 <span class="entry_type_array">
                   4
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">2x2 raw count block</div>
 
 
@@ -7835,7 +8304,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -7873,7 +8342,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -7911,7 +8380,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -7953,7 +8422,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -7992,7 +8461,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -8030,7 +8499,7 @@
                 <span class="entry_type_array">
                   9
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">3x3 matrix in row-major-order</div>
 
 
@@ -8064,7 +8533,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -8090,6 +8559,7 @@
             <td class="entry_tags">
               <ul class="entry_tags">
                   <li><a href="#tag_V1">V1</a></li>
+                  <li><a href="#tag_FULL">FULL</a></li>
               </ul>
             </td>
 
@@ -8105,7 +8575,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">float constants A,<wbr> B for the noise variance model</div>
 
 
@@ -8147,7 +8617,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -8186,7 +8656,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8305,7 +8775,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -8336,7 +8806,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -8364,14 +8834,18 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
               Duration each pixel is exposed to
-          light
+          light.<wbr>
+<br>
+<br>          If the sensor can't expose this exact duration,<wbr> it should shorten the
+          duration exposed to the nearest possible value (rather than expose longer).<wbr>
+          
             </td>
 
             <td class="entry_units">
@@ -8400,7 +8874,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -8439,7 +8913,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -8448,6 +8922,10 @@
               Gain applied to image data.<wbr> Must be
           implemented through analog gain only if set to values
           below 'maximum analog sensitivity'.<wbr>
+<br>
+<br>          If the sensor can't apply this exact gain,<wbr> it should lessen the
+          gain to the nearest possible value (rather than gain more).<wbr>
+          
             </td>
 
             <td class="entry_units">
@@ -8476,7 +8954,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int64</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -8507,6 +8985,45 @@
 
           </tr> <!-- end of entry -->
         
+                
+          <tr class="entry" id="dynamic_android.sensor.temperature">
+            <td class="entry_name">android.<wbr>sensor.<wbr>temperature</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+              <span class="entry_type_visibility"> [public]</span>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The temperature of the sensor,<wbr> sampled at the time
+          exposure began for this frame.<wbr>
+<br>
+<br>          The thermal diode being queried should be inside the sensor PCB,<wbr> or
+          somewhere close to it.<wbr>
+          
+            </td>
+
+            <td class="entry_units">
+              celsius
+            </td>
+
+            <td class="entry_range">
+              Optional.<wbr> This value is missing if no temperature is available.<wbr>
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_FULL">FULL</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
         
 
       <!-- end of kind -->
@@ -8518,7 +9035,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -8546,7 +9063,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8592,7 +9109,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -8627,7 +9144,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -8655,7 +9172,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8706,7 +9223,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -8734,7 +9251,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8764,10 +9281,14 @@
 
             <td class="entry_range">
               
-          android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+          android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
             </td>
 
             <td class="entry_notes">
+              Whether face detection is enabled,<wbr> and whether it
+          should output just the basic fields or the full set of
+          fields.<wbr> Value must be one of the
+          android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -8784,7 +9305,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8825,7 +9346,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -8860,13 +9381,54 @@
 
           </tr> <!-- end of entry -->
         
+                
+          <tr class="entry" id="controls_android.statistics.lensShadingMapMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>lens<wbr>Shading<wbr>Map<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+              <span class="entry_type_visibility"> [public]</span>
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether the HAL needs to output the lens
+          shading map in output result metadata
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When set to ON,<wbr>
+          android.<wbr>statistics.<wbr>lens<wbr>Shading<wbr>Map must be provided in
+          the output result metdata.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
         
 
       <!-- end of kind -->
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -8900,8 +9462,8 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
-                <div class="entry_type_notes">List of enums</div>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">List of enums from android.<wbr>statistics.<wbr>face<wbr>Detect<wbr>Mode</div>
 
 
             </td> <!-- entry_type -->
@@ -8912,13 +9474,27 @@
             </td>
 
             <td class="entry_units">
+              List of enum:
+            OFF
+            SIMPLE
+            FULL
             </td>
 
             <td class="entry_range">
-              OFF
             </td>
 
             <td class="entry_notes">
+              OFF means face detection is disabled,<wbr> it must
+            be included in the list.<wbr>
+<br>
+<br>            SIMPLE means the device supports the
+            android.<wbr>statistics.<wbr>face<wbr>Rectangles and
+            android.<wbr>statistics.<wbr>face<wbr>Scores outputs.<wbr>
+<br>
+<br>            FULL means the device additionally supports the
+            android.<wbr>statistics.<wbr>face<wbr>Ids and
+            android.<wbr>statistics.<wbr>face<wbr>Landmarks outputs.<wbr>
+            
             </td>
 
             <td class="entry_tags">
@@ -8932,7 +9508,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -8963,14 +9539,14 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
 
             <td class="entry_description">
-              If face detection is supported,<wbr> how many
-            faces can be detected at once
+              Maximum number of simultaneously detectable
+            faces
             </td>
 
             <td class="entry_units">
@@ -8995,7 +9571,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -9025,7 +9601,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [system]</span>
 
 
             </td> <!-- entry_type -->
@@ -9059,7 +9635,7 @@
                 <span class="entry_type_array">
                   2
                 </span>
-
+              <span class="entry_type_visibility"> [system as size]</span>
                 <div class="entry_type_notes">width x height</div>
 
 
@@ -9094,7 +9670,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -9122,7 +9698,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -9152,10 +9728,14 @@
 
             <td class="entry_range">
               
-          android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+          android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
             </td>
 
             <td class="entry_notes">
+              Whether face detection is enabled,<wbr> and whether it
+          should output just the basic fields or the full set of
+          fields.<wbr> Value must be one of the
+          android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9176,7 +9756,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -9214,7 +9794,7 @@
                 <span class="entry_type_array">
                   n x 6
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
                 <div class="entry_type_notes">(leftEyeX,<wbr> leftEyeY,<wbr> rightEyeX,<wbr> rightEyeY,<wbr> mouthX,<wbr> mouthY)</div>
 
 
@@ -9253,7 +9833,7 @@
                 <span class="entry_type_array">
                   n x 4
                 </span>
-
+              <span class="entry_type_visibility"> [public as rectangle]</span>
                 <div class="entry_type_notes">(xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax).<wbr> (0,<wbr>0) is top-left of active pixel area</div>
 
 
@@ -9292,7 +9872,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -9306,11 +9886,12 @@
             </td>
 
             <td class="entry_range">
-              0-100
+              1-100
             </td>
 
             <td class="entry_notes">
-              Only available if faceDetectMode != OFF
+              Only available if faceDetectMode != OFF.<wbr> The value should be
+          meaningful (for example,<wbr> setting 100 at all times is illegal).<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9331,7 +9912,7 @@
                 <span class="entry_type_array">
                   n x 3
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">count of pixels for each color channel that fall into each histogram bucket,<wbr> scaled to be between 0 and maxHistogramCount</div>
 
 
@@ -9369,7 +9950,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -9414,7 +9995,7 @@
                 <span class="entry_type_array">
                   n x m x 3
                 </span>
-
+              <span class="entry_type_visibility"> [system]</span>
                 <div class="entry_type_notes">estimated sharpness for each region of the input image.<wbr> Normalized to be between 0 and maxSharpnessMapValue.<wbr> Higher values mean sharper (better focused)</div>
 
 
@@ -9450,7 +10031,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [system as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -9485,6 +10066,193 @@
 
           </tr> <!-- end of entry -->
         
+                
+          <tr class="entry" id="dynamic_android.statistics.lensShadingMap">
+            <td class="entry_name">android.<wbr>statistics.<wbr>lens<wbr>Shading<wbr>Map</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4 x n x m
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">2D array of float gain factors per channel to correct lens shading</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A low-resolution map of lens shading,<wbr> per
+          color channel
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Each gain factor is >= 1
+            </td>
+
+            <td class="entry_notes">
+              Assume bilinear interpolation of map.<wbr> The least
+          shaded section of the image should have a gain factor
+          of 1; all other sections should have gains above 1.<wbr>
+          the map should be on the order of 30-40 rows,<wbr> and
+          must be smaller than 64x64.<wbr>
+<br>
+<br>          When android.<wbr>color<wbr>Correction.<wbr>mode = TRANSFORM_<wbr>MATRIX,<wbr> the map
+          must take into account the colorCorrection settings.<wbr>
+          
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.predictedColorGains">
+            <td class="entry_name">android.<wbr>statistics.<wbr>predicted<wbr>Color<wbr>Gains</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">A 1D array of floats for 4 color channel gains</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The best-fit color channel gains calculated
+          by the HAL's statistics units for the current output frame
+          
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              
+          This may be different than the gains used for this frame,<wbr>
+          since statistics processing on data from a new frame
+          typically completes after the transform has already been
+          applied to that frame.<wbr>
+<br>
+<br>          The 4 channel gains are defined in Bayer domain,<wbr>
+          see android.<wbr>color<wbr>Correction.<wbr>gains for details.<wbr>
+<br>
+<br>          This value should always be calculated by the AWB block,<wbr>
+          regardless of the android.<wbr>control.<wbr>* current values.<wbr>
+          
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.predictedColorTransform">
+            <td class="entry_name">android.<wbr>statistics.<wbr>predicted<wbr>Color<wbr>Transform</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3 x 3
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">3x3 rational matrix in row-major order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The best-fit color transform matrix estimate
+          calculated by the HAL's statistics units for the current
+          output frame
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              The HAL must provide the estimate from its
+          statistics unit on the white balance transforms to use
+          for the next frame.<wbr> These are the values the HAL believes
+          are the best fit for the current output frame.<wbr> This may
+          be different than the transform used for this frame,<wbr> since
+          statistics processing on data from a new frame typically
+          completes after the transform has already been applied to
+          that frame.<wbr>
+<br>
+<br>          These estimates must be provided for all frames,<wbr> even if
+          capture settings and color transforms are set by the application.<wbr>
+<br>
+<br>          This value should always be calculated by the AWB block,<wbr>
+          regardless of the android.<wbr>control.<wbr>* current values.<wbr>
+          
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.sceneFlicker">
+            <td class="entry_name">android.<wbr>statistics.<wbr>scene<wbr>Flicker</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+              <span class="entry_type_visibility"> [public]</span>
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">NONE</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">50HZ</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">60HZ</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The HAL estimated scene illumination lighting
+          frequency
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Report NONE if there doesn't appear to be flickering
+          illumination
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
         
 
       <!-- end of kind -->
@@ -9496,7 +10264,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -9523,8 +10291,13 @@
             <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
 
-
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9543,6 +10316,10 @@
             </td>
 
             <td class="entry_notes">
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the blue
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          See android.<wbr>tonemap.<wbr>curve<wbr>Red for more details.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9555,8 +10332,13 @@
             <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
 
-
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9575,6 +10357,10 @@
             </td>
 
             <td class="entry_notes">
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the green
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          See android.<wbr>tonemap.<wbr>curve<wbr>Red for more details.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9592,8 +10378,8 @@
                 <span class="entry_type_array">
                   n x 2
                 </span>
-
-                <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9607,14 +10393,21 @@
             </td>
 
             <td class="entry_range">
-              0-1 on input and output coordinates.<wbr> Max entry
-          count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+              0-1 on input and output coordinates.<wbr>
             </td>
 
             <td class="entry_notes">
-              .<wbr>The input range must be monotonically increasing
-          with N,<wbr> and values between entries should be linearly
-          interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the red
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          Since the input and output ranges may vary depending on
+          the camera pipeline,<wbr> the input and output pixel values
+          are represented by normalized floating-point values
+          between 0 and 1,<wbr> with 0 == black and 1 == white.<wbr>
+<br>
+<br>          The curve should be linearly interpolated between the
+          defined points.<wbr> The points will be listed in increasing
+          order of P_<wbr>IN.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
           0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
           for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
           0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
@@ -9634,7 +10427,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -9679,7 +10472,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -9707,7 +10500,7 @@
             <td class="entry_type">
                 <span class="entry_type_name">int32</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
 
             </td> <!-- entry_type -->
@@ -9738,7 +10531,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -9765,8 +10558,13 @@
             <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
 
-
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9785,6 +10583,10 @@
             </td>
 
             <td class="entry_notes">
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the blue
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          See android.<wbr>tonemap.<wbr>curve<wbr>Red for more details.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9797,8 +10599,13 @@
             <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
             <td class="entry_type">
                 <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
 
-
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9817,6 +10624,10 @@
             </td>
 
             <td class="entry_notes">
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the green
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          See android.<wbr>tonemap.<wbr>curve<wbr>Red for more details.<wbr>
             </td>
 
             <td class="entry_tags">
@@ -9834,8 +10645,8 @@
                 <span class="entry_type_array">
                   n x 2
                 </span>
-
-                <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+              <span class="entry_type_visibility"> [public]</span>
+                <div class="entry_type_notes">1D array of float pairs (P_<wbr>IN,<wbr> P_<wbr>OUT).<wbr> The maximum number of pairs is specified by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points.<wbr></div>
 
 
             </td> <!-- entry_type -->
@@ -9849,14 +10660,21 @@
             </td>
 
             <td class="entry_range">
-              0-1 on input and output coordinates.<wbr> Max entry
-          count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+              0-1 on input and output coordinates.<wbr>
             </td>
 
             <td class="entry_notes">
-              .<wbr>The input range must be monotonically increasing
-          with N,<wbr> and values between entries should be linearly
-          interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+              Tonemapping /<wbr> contrast /<wbr> gamma curve for the red
+          channel,<wbr> to use when android.<wbr>tonemap.<wbr>mode is CONTRAST_<wbr>CURVE.<wbr>
+<br>
+<br>          Since the input and output ranges may vary depending on
+          the camera pipeline,<wbr> the input and output pixel values
+          are represented by normalized floating-point values
+          between 0 and 1,<wbr> with 0 == black and 1 == white.<wbr>
+<br>
+<br>          The curve should be linearly interpolated between the
+          defined points.<wbr> The points will be listed in increasing
+          order of P_<wbr>IN.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
           0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
           for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
           0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
@@ -9876,7 +10694,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -9926,7 +10744,7 @@
 
       <tr><td colspan="7" class="kind">controls</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -9954,7 +10772,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [hidden as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -10003,7 +10821,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">dynamic</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -10031,7 +10849,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [hidden as boolean]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -10080,7 +10898,7 @@
       </tbody>
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -10112,7 +10930,7 @@
                 <span class="entry_type_array">
                   n
                 </span>
-
+              <span class="entry_type_visibility"> [hidden]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -10153,7 +10971,7 @@
 
       <tr><td colspan="7" class="kind">static</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -10181,7 +10999,7 @@
             <td class="entry_type">
                 <span class="entry_type_name entry_type_name_enum">byte</span>
 
-
+              <span class="entry_type_visibility"> [public]</span>
 
                 <ul class="entry_type_enum">
                   <li>
@@ -10196,12 +11014,13 @@
 
             <td class="entry_description">
               
-          The camera 3 HAL device can implement one of two possible operational modes;
-          limited and full.<wbr> Full support is expected from new higher-end
-          devices.<wbr> Limited mode has hardware requirements roughly in line with those
-          for a camera HAL device v1 implementation,<wbr> and is expected from older or
-          inexpensive devices.<wbr> Full is a strict superset of limited,<wbr> and they share the
-          same essential operational flow.<wbr>
+          The camera 3 HAL device can implement one of two possible
+          operational modes; limited and full.<wbr> Full support is
+          expected from new higher-end devices.<wbr> Limited mode has
+          hardware requirements roughly in line with those for a
+          camera HAL device v1 implementation,<wbr> and is expected from
+          older or inexpensive devices.<wbr> Full is a strict superset of
+          limited,<wbr> and they share the same essential operational flow.<wbr>
 <br>
 <br>          For full details refer to "S3.<wbr> Operational Modes" in camera3.<wbr>h
           
@@ -10228,6 +11047,181 @@
       </tbody>
 
   <!-- end of section -->
+  <tr><td colspan="7" id="section_blackLevel" class="section">blackLevel</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead class="entries_header">
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.blackLevel.lock">
+            <td class="entry_name">android.<wbr>black<wbr>Level.<wbr>lock</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+              <span class="entry_type_visibility"> [public as boolean]</span>
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+               Whether black-level compensation is locked
+          to its current values,<wbr> or is free to vary
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When set to ON,<wbr> the values used for black-level
+          compensation must not change until the lock is set to
+          OFF
+<br>
+<br>          Since changes to certain capture parameters (such as
+          exposure time) may require resetting of black level
+          compensation,<wbr> the HAL must report whether setting the
+          black level lock was successful in the output result
+          metadata.<wbr>
+<br>
+<br>          The black level locking must happen at the sensor,<wbr> and not at the ISP.<wbr>
+          If for some reason black level locking is no longer legal (for example,<wbr>
+          the analog gain has changed,<wbr> which forces black levels to be
+          recalculated),<wbr> then the HAL is free to override this request (and it
+          must report 'OFF' when this does happen) until the next time locking
+          is legal again.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead class="entries_header">
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.blackLevel.lock">
+            <td class="entry_name">android.<wbr>black<wbr>Level.<wbr>lock</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+              <span class="entry_type_visibility"> [public as boolean]</span>
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+               Whether black-level compensation is locked
+          to its current values,<wbr> or is free to vary
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When set to ON,<wbr> the values used for black-level
+          compensation must not change until the lock is set to
+          OFF
+<br>
+<br>          Since changes to certain capture parameters (such as
+          exposure time) may require resetting of black level
+          compensation,<wbr> the HAL must report whether setting the
+          black level lock was successful in the output result
+          metadata.<wbr>
+<br>
+<br>          The black level locking must happen at the sensor,<wbr> and not at the ISP.<wbr>
+          If for some reason black level locking is no longer legal (for example,<wbr>
+          the analog gain has changed,<wbr> which forces black levels to be
+          recalculated),<wbr> then the HAL is free to override this request (and it
+          must report 'OFF' when this does happen) until the next time locking
+          is legal again.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_HAL2">HAL2</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
 <!-- </namespace> -->
   </table>
 
@@ -10295,7 +11289,7 @@
           <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
           <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
           <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
-          <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+          <li><a href="#static_android.sensor.info.sensitivityRange">android.sensor.info.sensitivityRange</a> (static)</li>
           <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
           <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
           <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
@@ -10338,7 +11332,7 @@
           <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
           <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
           <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
-          <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+          <li><a href="#static_android.sensor.info.sensitivityRange">android.sensor.info.sensitivityRange</a> (static)</li>
           <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
           <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
           <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
@@ -10370,7 +11364,6 @@
     
         <ul class="tags_entries">
           <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
-          <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
           <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
           <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
           <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
@@ -10391,6 +11384,25 @@
           <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
         </ul>
       </li> <!-- tag_EXIF -->
+      <li id="tag_HAL2">HAL2 - 
+        Entry is only used by camera device HAL 2.x
+    
+        <ul class="tags_entries">
+          <li><a href="#controls_android.request.inputStreams">android.request.inputStreams</a> (controls)</li>
+          <li><a href="#controls_android.request.outputStreams">android.request.outputStreams</a> (controls)</li>
+          <li><a href="#controls_android.request.type">android.request.type</a> (controls)</li>
+          <li><a href="#controls_android.blackLevel.lock">android.blackLevel.lock</a> (controls)</li>
+        </ul>
+      </li> <!-- tag_HAL2 -->
+      <li id="tag_FULL">FULL - 
+        Entry is required for full hardware level devices, and optional for other hardware levels
+    
+        <ul class="tags_entries">
+          <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
+          <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
+          <li><a href="#dynamic_android.sensor.temperature">android.sensor.temperature</a> (dynamic)</li>
+        </ul>
+      </li> <!-- tag_FULL -->
     </ul>
   </div>
 
diff --git a/camera/docs/html.mako b/camera/docs/html.mako
index b1b97597..937e19c1 100644
--- a/camera/docs/html.mako
+++ b/camera/docs/html.mako
@@ -18,31 +18,45 @@
 <head>
   <!-- automatically generated from html.mako. do NOT edit directly -->
   <meta charset="utf-8" />
-  <title>Android Camera HAL2.0 Properties</title>
+  <title>Android Camera HAL3.0 Properties</title>
   <style type="text/css">
-    .section { font-size: 1.5em; font-weight: bold; background-color: beige; padding: 0.5em 0em 0.5em 0.1em }
-    .kind { font-size: 1.2em; font-weight: bold; padding-left: 0.5em; background-color: gray }
-    .entry { background-color: burlywood }
+     body { background-color: #f7f7f7; font-family: Roboto, sans-serif;}
+     h1 { color: #333333; }
+     h2 { color: #333333; }
+     a:link { color: #258aaf; text-decoration: none}
+     a:hover { color: #459aaf; text-decoration: underline }
+     a:visited { color: #154a5f; text-decoration: none}
+    .section { color: #eeeeee; font-size: 1.5em; font-weight: bold; background-color: #888888; padding: 0.5em 0em 0.5em 0.5em; border-width: thick thin thin thin; border-color: #111111 #777777 #777777 #777777}
+    .kind { color: #eeeeee; font-size: 1.2em; font-weight: bold; padding-left: 1.5em; background-color: #aaaaaa }
+    .entry { background-color: #f0f0f0 }
+    .entries_header { background-color: #dddddd; text-align: center}
+
+    /* toc style */
+    .toc_section_header { font-size:1.3em;  }
+    .toc_kind_header { font-size:1.2em;  }
 
     /* table column sizes */
-    table { table-layout: fixed; width: 100%; word-wrap: break-word }
-    td,th { border: 1px solid;  }
+    table { border-collapse:collapse; table-layout: fixed; width: 100%; word-wrap: break-word }
+    td,th { border: 1px solid; border-color: #aaaaaa; padding-left: 0.5em; padding-right: 0.5em }
     .th_name { width: 20% }
     .th_units { width: 10% }
     .th_tags { width: 5% }
-    .th_notes { width: 30% }
+    .th_notes { width: 25% }
     .th_type { width: 20% }
+    .th_description { width: 20% }
+    .th_range { width: 10% }
     td { font-size: 0.9em; }
 
     /* hide the first thead, we need it there only to enforce column sizes */
     .thead_dummy { visibility: hidden; }
 
     /* Entry flair */
-    .entry_name { font-family: monospace; font-style: italic; }
+    .entry_name { color: #333333; padding-left:1.0em; font-size:1.1em; font-family: monospace; }
 
     /* Entry type flair */
-    .entry_type_name { color: darkgreen; font-weight: bold; }
-    .entry_type_name_enum:after { color: darkgreen; font-weight: bold; content:" (enum)" }
+    .entry_type_name { font-size:1.1em; color: #669900; font-weight: bold;}
+    .entry_type_name_enum:after { color: #669900; font-weight: bold; content:" (enum)" }
+    .entry_type_visibility { font-weight: bolder; padding-left:1em}
     .entry_type_enum_name { font-family: monospace; font-weight: bolder; }
     .entry_type_enum_notes:before { content:" - " }
     .entry_type_enum_value:before { content:" = " }
@@ -50,6 +64,8 @@
     .entry ul { margin: 0 0 0 0; list-style-position: inside; padding-left: 0.5em; }
     .entry ul li { padding: 0 0 0 0; margin: 0 0 0 0;}
 
+    /* Entry visibility flair */
+
     /* Entry tags flair */
     .entry_tags ul { list-style-type: none; }
 
@@ -99,26 +115,41 @@
     return re.sub(r"(\r?\n)(\r?\n)", r"\1<br>\2<br>", text)
 %>
 
-
 <body>
-  <h1>Android Camera HAL2.0 Properties</h1>
+  <h1>Android Camera HAL3.0 Properties</h1>
+\
+<%def name="insert_toc_body(node)">
+  % for nested in node.namespaces:
+${    insert_toc_body(nested)}
+  % endfor
+  % for entry in node.merged_entries:
+            <li><a href="#${entry.kind}_${entry.name}">${entry.name}</a></li>
+  % endfor
+</%def>
 
   <h2>Table of Contents</h2>
   <ul class="toc">
-    <li><a href="#tag_index">Tags</a></li>
-
-
-    % for section in metadata.find_all(lambda x: isinstance(x, metadata_model.Section)):
-    <li><p class="toc_section"><a href="#section_${section.name}">${section.name}</a></p>
-    <ul class="toc_section">
-      % for prop in section.find_all(lambda x: isinstance(x, metadata_model.Entry)):
-        <li><a href="#${prop.kind}_${prop.name}">${prop.name}</a> (${prop.kind})</li>
+    <li><a href="#tag_index" class="toc_section_header">Tags</a></li>
+% for root in metadata.outer_namespaces:
+  % for section in root.sections:
+    <li>
+      <span class="toc_section_header"><a href="#section_${section.name}">${section.name}</a></span>
+      <ul class="toc_section">
+      % for kind in section.merged_kinds: # dynamic,static,controls
+        <li>
+          <span class="toc_kind_header">${kind.name}</span>
+          <ul class="toc_section">\
+${          insert_toc_body(kind)}\
+          </ul>
+        </li>
       % endfor
-    </ul>
-    </li> <!-- toc_section -->
-    % endfor
+      </ul> <!-- toc_section -->
+    </li>
+  % endfor
+% endfor
   </ul>
 
+
   <h1>Properties</h1>
   <table class="properties">
 
@@ -146,7 +177,7 @@
     % for kind in section.merged_kinds: # dynamic,static,controls
       <tr><td colspan="7" class="kind">${kind.name}</td></tr>
 
-      <thead>
+      <thead class="entries_header">
         <tr>
           <th class="th_name">Property Name</th>
           <th class="th_type">Type</th>
@@ -211,7 +242,7 @@
                 % endfor
                 </ul>
               % endif
-
+              <span class="entry_type_visibility"> [${prop.applied_visibility}${" as %s" %prop.typedef.name if prop.typedef else ""}]</span>
               % if prop.type_notes is not None:
                 <div class="entry_type_notes">${prop.type_notes | wbr}</div>
               % endif
diff --git a/camera/docs/metadata-generate b/camera/docs/metadata-generate
index 59aaff28..ec9e9476 100755
--- a/camera/docs/metadata-generate
+++ b/camera/docs/metadata-generate
@@ -21,18 +21,41 @@
 #   docs.html
 #   ../src/camera_metadata_tag_info.c
 #   ../src/camera_metadata_tags.h
-#
+#   ../../../../cts/tests/tests/hardware/src/android/hardware/camera2/cts/CameraCharacteristicsTest.java
+#   ../../../../cts/tests/tests/hardware/src/android/hardware/camera2/cts/CameraCaptureResultTest.java
+#   ../../../../frameworks/base/core/java/android/hardware/camera2/CameraCharacteristics.java
+#   ../../../../frameworks/base/core/java/android/hardware/camera2/CaptureRequest.java
+#   ../../../../frameworks/base/core/java/android/hardware/camera2/CaptureResult.java
+
+if [[ -z $ANDROID_BUILD_TOP ]]; then
+    echo "Please source build/envsetup.sh before running script" >& 2
+    exit 1
+fi
 
 thisdir=$(cd "$(dirname "$0")"; pwd)
+fwkdir="$ANDROID_BUILD_TOP/frameworks/base/core/java/android/hardware/camera2/"
+ctsdir="$ANDROID_BUILD_TOP/cts/tests/tests/hardware/src/android/hardware/camera2/cts"
+outdir="$ANDROID_PRODUCT_OUT/obj/ETC/system-media-camera-docs_intermediates"
+out_files=()
 
 function relpath() {
     python -c "import os.path; print os.path.relpath('$1', '$PWD')"
 }
 
+# Generates a file. Appends to $out_files array as a side effect.
 function gen_file() {
     local in=$thisdir/$1
     local out=$thisdir/$2
 
+    gen_file_abs "$in" "$out"
+    return $?
+}
+
+function gen_file_abs() {
+    local in="$1"
+    local out="$2"
+    local intermediates="$3"
+
     python $thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $in $out
 
     local succ=$?
@@ -40,6 +63,9 @@ function gen_file() {
     if [[ $succ -eq 0 ]]
     then
         echo "OK: Generated $(relpath "$out")"
+        if [[ "$intermediates" != "no" ]]; then
+          out_files+=$'\n'" $out"
+        fi
     else
         echo "FAIL: Errors while generating $(relpath "$out")" >& 2
     fi
@@ -47,13 +73,125 @@ function gen_file() {
     return $succ
 }
 
+# Print a list of git repository paths which were affected after file generation
+function affected_git_directories() {
+    local input_files=($@)
+    local git_directories=()
+
+    for file in "${input_files[@]}"; do
+        local dir_path="$(dirname "$file")"
+        echo "Trying to cd into $dir_path" >& /dev/null
+        # Absolute path to the git repository root of that file
+        local git_path="$(cd "$dir_path";
+                          git rev-parse --show-toplevel 2> /dev/null)"
+        if [[ $? -eq 0 ]]; then
+            # Both staged and unstaged changes
+            local diff_result="$(cd "$dir_path";
+                                 git status --porcelain | egrep -c -v '^[?][?]')"
+            echo "Diff result was $diff_result" >& /dev/null
+            echo "Diff result was $diff_result" >& /dev/null
+            if [[ $diff_result -eq 0 ]]; then
+                echo "No changes in ${git_path}" >& /dev/null
+            else
+                echo "There are changes in ${git_path}" >& /dev/null
+                git_directories+=("$git_path")
+            fi
+        fi
+    done
+
+    # print as result the unique list of git directories affected
+    printf %s\\n "${git_directories[@]}" | sort | uniq
+}
+
+# Insert a file into the middle of another, starting at the line containing the
+# start delim and ending on the end delim, both of which are replaced
+function insert_file() {
+    local src_part="$1"
+    local dst_file="$2"
+    local start_delim="/*@O~"
+    local end_delim="~O@*/"
+
+    local start_line="$(grep -n -F "${start_delim}" "${dst_file}" | cut -d: -f1)"
+    local end_line="$(grep -n -F "${end_delim}" "${dst_file}" | cut -d: -f1)"
+
+    # Adjust cutoff points to use start/end line from inserted file
+    (( start_line-- ))
+    (( end_line++ ))
+
+    # Do some basic sanity checks
+
+    if [[ -z "$start_line" ]]; then
+       echo "No starting delimiter found in ${dst_file}" >& 2
+       echo "FAIL: Errors in inserting into $(relpath ${dst_file})" >& 2
+       return 1
+    fi
+
+    if [[ -z "$end_line" ]]; then
+       echo "No ending delimiter found in ${dst_file}" >& 2
+       echo "FAIL: Errors in inserting into $(relpath ${dst_file})" >& 2
+       return 1
+    fi
+
+    if [[ "$start_line" -ge "$end_line" ]]; then
+       echo "Starting delim later than ending delim: $start_line vs $end_line" >& 2
+       echo "FAIL: Errors in inserting into $(relpath ${dst_file})" >& 2
+       return 1
+    fi
+
+    local tmp_name=$(mktemp -t XXXXXXXX)
+
+    # Compose the three parts of the final file together
+
+    head -n "$start_line" "${dst_file}" > "${tmp_name}"
+    cat "${src_part}" >> "${tmp_name}"
+    tail -n "+${end_line}" "${dst_file}" >> "${tmp_name}"
+
+    # And replace the destination file with the new version
+
+    mv "${tmp_name}" "${dst_file}"
+    echo "OK: Inserted $(relpath "$src_part") into $(relpath "$dst_file")"
+    out_files+=$'\n'" $dst_file"
+}
+
 $thisdir/metadata-check-dependencies || exit 1
 $thisdir/metadata-validate $thisdir/metadata_properties.xml || exit 1
 $thisdir/metadata-parser-sanity-check || exit 1
+
+# Generate HTML properties documentation
 gen_file html.mako docs.html || exit 1
+
+# Generate C API headers and implementation
 gen_file camera_metadata_tag_info.mako ../src/camera_metadata_tag_info.c || exit 1
 gen_file camera_metadata_tags.mako ../include/system/camera_metadata_tags.h || exit 1
 
+# Generate Java API definitions
+mkdir -p "${outdir}"
+gen_file_abs CameraMetadataEnums.mako "$outdir/CameraMetadataEnums.java.part" no || exit 1
+gen_file_abs CameraCharacteristicsKeys.mako "$outdir/CameraCharacteristicsKeys.java.part" no || exit 1
+gen_file_abs CaptureRequestKeys.mako "$outdir/CaptureRequestKeys.java.part" no || exit 1
+gen_file_abs CaptureResultKeys.mako "$outdir/CaptureResultKeys.java.part" no || exit 1
+gen_file_abs CameraCaptureResultTest.mako "$outdir/CameraCaptureResultTest.java.part" no || exit 1
+
+insert_file "$outdir/CameraMetadataEnums.java.part" "$fwkdir/CameraMetadata.java" || exit 1
+insert_file "$outdir/CameraCharacteristicsKeys.java.part" "$fwkdir/CameraCharacteristics.java" || exit 1
+insert_file "$outdir/CaptureRequestKeys.java.part" "$fwkdir/CaptureRequest.java" || exit 1
+insert_file "$outdir/CaptureResultKeys.java.part" "$fwkdir/CaptureResult.java" || exit 1
+
+# Generate CTS tests
+gen_file_abs CameraCharacteristicsTest.mako "$ctsdir/CameraCharacteristicsTest.java" || exit 1
+insert_file "$outdir/CameraCaptureResultTest.java.part" "$ctsdir/CameraCaptureResultTest.java" || exit 1
+
+echo ""
+echo "===================================================="
 echo "Successfully generated all metadata source files"
+echo "===================================================="
+echo ""
+
+echo "****************************************************"
+echo "The following git repositories need to be committed:"
+echo "****************************************************"
+echo ""
+affected_git_directories "${out_files[@]}"
+echo ""
 
 exit 0
diff --git a/camera/docs/metadata-validate b/camera/docs/metadata-validate
index d507d8e4..a7755adf 100755
--- a/camera/docs/metadata-validate
+++ b/camera/docs/metadata-validate
@@ -28,6 +28,6 @@ fi
 schema=$thisdir/metadata_properties.xsd
 doc=$1
 
-xmllint --noout --schema $schema $out $doc || exit 1
+xmllint --noout --schema $schema $doc || exit 1
 python $thisdir/metadata_validate.py $doc || exit 1
 
diff --git a/camera/docs/metadata_helpers.py b/camera/docs/metadata_helpers.py
index fd09d982..e897ed01 100644
--- a/camera/docs/metadata_helpers.py
+++ b/camera/docs/metadata_helpers.py
@@ -19,6 +19,7 @@ A set of helpers for rendering Mako templates with a Metadata model.
 """
 
 import metadata_model
+import re
 from collections import OrderedDict
 
 _context_buf = None
@@ -113,6 +114,65 @@ def path_name(node):
 
   return ".".join((i.name for i in path))
 
+def has_descendants_with_enums(node):
+  """
+  Determine whether or not the current node is or has any descendants with an
+  Enum node.
+
+  Args:
+    node: a Node instance
+
+  Returns:
+    True if it finds an Enum node in the subtree, False otherwise
+  """
+  return bool(node.find_first(lambda x: isinstance(x, metadata_model.Enum)))
+
+def get_children_by_throwing_away_kind(node, member='entries'):
+  """
+  Get the children of this node by compressing the subtree together by removing
+  the kind and then combining any children nodes with the same name together.
+
+  Args:
+    node: An instance of Section, InnerNamespace, or Kind
+
+  Returns:
+    An iterable over the combined children of the subtree of node,
+    as if the Kinds never existed.
+
+  Remarks:
+    Not recursive. Call this function repeatedly on each child.
+  """
+
+  if isinstance(node, metadata_model.Section):
+    # Note that this makes jump from Section to Kind,
+    # skipping the Kind entirely in the tree.
+    node_to_combine = node.combine_kinds_into_single_node()
+  else:
+    node_to_combine = node
+
+  combined_kind = node_to_combine.combine_children_by_name()
+
+  return (i for i in getattr(combined_kind, member))
+
+def get_children_by_filtering_kind(section, kind_name, member='entries'):
+  """
+  Takes a section and yields the children of the merged kind under this section.
+
+  Args:
+    section: An instance of Section
+    kind_name: A name of the kind, i.e. 'dynamic' or 'static' or 'controls'
+
+  Returns:
+    An iterable over the children of the specified merged kind.
+  """
+
+  matched_kind = next((i for i in section.merged_kinds if i.name == kind_name), None)
+
+  if matched_kind:
+    return getattr(matched_kind, member)
+  else:
+    return ()
+
 ##
 ## Filters
 ##
@@ -241,3 +301,400 @@ def ctype_enum(what):
     code doesn't support enums directly yet.
   """
   return 'TYPE_%s' %(what.upper())
+
+
+# Calculate a java type name from an entry with a Typedef node
+def _jtypedef_type(entry):
+  typedef = entry.typedef
+  additional = ''
+
+  # Hacky way to deal with arrays. Assume that if we have
+  # size 'Constant x N' the Constant is part of the Typedef size.
+  # So something sized just 'Constant', 'Constant1 x Constant2', etc
+  # is not treated as a real java array.
+  if entry.container == 'array':
+    has_variable_size = False
+    for size in entry.container_sizes:
+      try:
+        size_int = int(size)
+      except ValueError:
+        has_variable_size = True
+
+    if has_variable_size:
+      additional = '[]'
+
+  try:
+    name = typedef.languages['java']
+
+    return "%s%s" %(name, additional)
+  except KeyError:
+    return None
+
+# Box if primitive. Otherwise leave unboxed.
+def _jtype_box(type_name):
+  mapping = {
+    'boolean': 'Boolean',
+    'byte': 'Byte',
+    'int': 'Integer',
+    'float': 'Float',
+    'double': 'Double',
+    'long': 'Long'
+  }
+
+  return mapping.get(type_name, type_name)
+
+def jtype_unboxed(entry):
+  """
+  Calculate the Java type from an entry type string, to be used whenever we
+  need the regular type in Java. It's not boxed, so it can't be used as a
+  generic type argument when the entry type happens to resolve to a primitive.
+
+  Remarks:
+    Since Java generics cannot be instantiated with primitives, this version
+    is not applicable in that case. Use jtype_boxed instead for that.
+
+  Returns:
+    The string representing the Java type.
+  """
+  if not isinstance(entry, metadata_model.Entry):
+    raise ValueError("Expected entry to be an instance of Entry")
+
+  metadata_type = entry.type
+
+  java_type = None
+
+  if entry.typedef:
+    typedef_name = _jtypedef_type(entry)
+    if typedef_name:
+      java_type = typedef_name # already takes into account arrays
+
+  if not java_type:
+    if not java_type and entry.enum:
+      # Always map enums to Java ints, unless there's a typedef override
+      base_type = 'int'
+
+    else:
+      mapping = {
+        'int32': 'int',
+        'int64': 'long',
+        'float': 'float',
+        'double': 'double',
+        'byte': 'byte',
+        'rational': 'Rational'
+      }
+
+      base_type = mapping[metadata_type]
+
+    # Convert to array (enums, basic types)
+    if entry.container == 'array':
+      additional = '[]'
+    else:
+      additional = ''
+
+    java_type = '%s%s' %(base_type, additional)
+
+  # Now box this sucker.
+  return java_type
+
+def jtype_boxed(entry):
+  """
+  Calculate the Java type from an entry type string, to be used as a generic
+  type argument in Java. The type is guaranteed to inherit from Object.
+
+  It will only box when absolutely necessary, i.e. int -> Integer[], but
+  int[] -> int[].
+
+  Remarks:
+    Since Java generics cannot be instantiated with primitives, this version
+    will use boxed types when absolutely required.
+
+  Returns:
+    The string representing the boxed Java type.
+  """
+  unboxed_type = jtype_unboxed(entry)
+  return _jtype_box(unboxed_type)
+
+def _jtype_primitive(what):
+  """
+  Calculate the Java type from an entry type string.
+
+  Remarks:
+    Makes a special exception for Rational, since it's a primitive in terms of
+    the C-library camera_metadata type system.
+
+  Returns:
+    The string representing the primitive type
+  """
+  mapping = {
+    'int32': 'int',
+    'int64': 'long',
+    'float': 'float',
+    'double': 'double',
+    'byte': 'byte',
+    'rational': 'Rational'
+  }
+
+  try:
+    return mapping[what]
+  except KeyError as e:
+    raise ValueError("Can't map '%s' to a primitive, not supported" %what)
+
+def jclass(entry):
+  """
+  Calculate the java Class reference string for an entry.
+
+  Args:
+    entry: an Entry node
+
+  Example:
+    <entry name="some_int" type="int32"/>
+    <entry name="some_int_array" type="int32" container='array'/>
+
+    jclass(some_int) == 'int.class'
+    jclass(some_int_array) == 'int[].class'
+
+  Returns:
+    The ClassName.class string
+  """
+
+  return "%s.class" %jtype_unboxed(entry)
+
+def jidentifier(what):
+  """
+  Convert the input string into a valid Java identifier.
+
+  Args:
+    what: any identifier string
+
+  Returns:
+    String with added underscores if necessary.
+  """
+  if re.match("\d", what):
+    return "_%s" %what
+  else:
+    return what
+
+def enum_calculate_value_string(enum_value):
+  """
+  Calculate the value of the enum, even if it does not have one explicitly
+  defined.
+
+  This looks back for the first enum value that has a predefined value and then
+  applies addition until we get the right value, using C-enum semantics.
+
+  Args:
+    enum_value: an EnumValue node with a valid Enum parent
+
+  Example:
+    <enum>
+      <value>X</value>
+      <value id="5">Y</value>
+      <value>Z</value>
+    </enum>
+
+    enum_calculate_value_string(X) == '0'
+    enum_calculate_Value_string(Y) == '5'
+    enum_calculate_value_string(Z) == '6'
+
+  Returns:
+    String that represents the enum value as an integer literal.
+  """
+
+  enum_value_siblings = list(enum_value.parent.values)
+  this_index = enum_value_siblings.index(enum_value)
+
+  def is_hex_string(instr):
+    return bool(re.match('0x[a-f0-9]+$', instr, re.IGNORECASE))
+
+  base_value = 0
+  base_offset = 0
+  emit_as_hex = False
+
+  this_id = enum_value_siblings[this_index].id
+  while this_index != 0 and not this_id:
+    this_index -= 1
+    base_offset += 1
+    this_id = enum_value_siblings[this_index].id
+
+  if this_id:
+    base_value = int(this_id, 0)  # guess base
+    emit_as_hex = is_hex_string(this_id)
+
+  if emit_as_hex:
+    return "0x%X" %(base_value + base_offset)
+  else:
+    return "%d" %(base_value + base_offset)
+
+def enumerate_with_last(iterable):
+  """
+  Enumerate a sequence of iterable, while knowing if this element is the last in
+  the sequence or not.
+
+  Args:
+    iterable: an Iterable of some sequence
+
+  Yields:
+    (element, bool) where the bool is True iff the element is last in the seq.
+  """
+  it = (i for i in iterable)
+
+  first = next(it)  # OK: raises exception if it is empty
+
+  second = first  # for when we have only 1 element in iterable
+
+  try:
+    while True:
+      second = next(it)
+      # more elements remaining.
+      yield (first, False)
+      first = second
+  except StopIteration:
+    # last element. no more elements left
+    yield (second, True)
+
+def pascal_case(what):
+  """
+  Convert the first letter of a string to uppercase, to make the identifier
+  conform to PascalCase.
+
+  If there are dots, remove the dots, and capitalize the letter following
+  where the dot was. Letters that weren't following dots are left unchanged,
+  except for the first letter of the string (which is made upper-case).
+
+  Args:
+    what: a string representing some identifier
+
+  Returns:
+    String with first letter capitalized
+
+  Example:
+    pascal_case("helloWorld") == "HelloWorld"
+    pascal_case("foo") == "Foo"
+    pascal_case("hello.world") = "HelloWorld"
+    pascal_case("fooBar.fooBar") = "FooBarFooBar"
+  """
+  return "".join([s[0:1].upper() + s[1:] for s in what.split('.')])
+
+def jkey_identifier(what):
+  """
+  Return a Java identifier from a property name.
+
+  Args:
+    what: a string representing a property name.
+
+  Returns:
+    Java identifier corresponding to the property name. May need to be
+    prepended with the appropriate Java class name by the caller of this
+    function. Note that the outer namespace is stripped from the property
+    name.
+
+  Example:
+    jkey_identifier("android.lens.facing") == "LENS_FACING"
+  """
+  return csym(what[what.find('.') + 1:])
+
+def jenum_value(enum_entry, enum_value):
+  """
+  Calculate the Java name for an integer enum value
+
+  Args:
+    enum: An enum-typed Entry node
+    value: An EnumValue node for the enum
+
+  Returns:
+    String representing the Java symbol
+  """
+
+  cname = csym(enum_entry.name)
+  return cname[cname.find('_') + 1:] + '_' + enum_value.name
+
+def javadoc(text, indent = 4):
+  """
+  Format text block as a javadoc comment section
+
+  Args:
+    text: A multi-line string to format
+    indent: baseline level of indentation for javadoc block
+  Returns:
+    String with:
+    - Indent and * for insertion into a Javadoc comment block
+    - Leading/trailing whitespace removed
+    - Paragraph tags added on newlines between paragraphs
+
+  Example:
+    "This is a comment for Javadoc\n" +
+    "     with multiple lines, that should be   \n" +
+    "     formatted better\n" +
+    "\n" +
+    "    That covers multiple lines as well\n"
+
+    transforms to
+    "    * <p>\n" +
+    "    * This is a comment for Javadoc\n" +
+    "    * with multiple lines, that should be\n" +
+    "    * formatted better\n" +
+    "    * </p><p>\n" +
+    "    * That covers multiple lines as well\n" +
+    "    * </p>\n"
+  """
+  comment_prefix = " " * indent + " * ";
+  comment_para = comment_prefix + "</p><p>\n";
+  javatext = comment_prefix + "<p>\n";
+
+  in_body = False # Eat empty lines at start
+  first_paragraph = True
+  for line in ( line.strip() for line in text.splitlines() ):
+    if not line:
+      in_body = False # collapse multi-blank lines into one
+    else:
+      # Insert para end/start after a span of blank lines except for
+      # the first paragraph, which got a para start already
+      if not in_body and not first_paragraph:
+        javatext = javatext + comment_para
+
+      in_body = True
+      first_paragraph = False
+
+      javatext = javatext + comment_prefix + line + "\n";
+
+  # Close last para tag
+  javatext = javatext + comment_prefix + "</p>\n";
+
+  return javatext
+
+def any_visible(section, kind_name, visibilities):
+  """
+  Determine if entries in this section have an applied visibility that's in
+  the list of given visibilities.
+
+  Args:
+    section: A section of metadata
+    kind_name: A name of the kind, i.e. 'dynamic' or 'static' or 'controls'
+    visibilities: An iterable of visibilities to match against
+
+  Returns:
+    True if the section has any entries with any of the given visibilities. False otherwise.
+  """
+
+  for inner_namespace in get_children_by_filtering_kind(section, kind_name,
+                                                        'namespaces'):
+    if any(filter_visibility(inner_namespace.merged_entries, visibilities)):
+      return True
+
+  return any(filter_visibility(get_children_by_filtering_kind(section, kind_name,
+                                                              'merged_entries'),
+                               visibilities))
+
+
+def filter_visibility(entries, visibilities):
+  """
+  Remove entries whose applied visibility is not in the supplied visibilities.
+
+  Args:
+    entries: An iterable of Entry nodes
+    visibilities: An iterable of visibilities to filter against
+
+  Yields:
+    An iterable of Entry nodes
+  """
+  return (e for e in entries if e.applied_visibility in visibilities)
diff --git a/camera/docs/metadata_helpers_test.py b/camera/docs/metadata_helpers_test.py
new file mode 100644
index 00000000..f4335cc8
--- /dev/null
+++ b/camera/docs/metadata_helpers_test.py
@@ -0,0 +1,60 @@
+import unittest
+from unittest import TestCase
+from metadata_model import *
+from metadata_helpers import *
+
+class TestHelpers(TestCase):
+
+  def test_enum_calculate_value_string(self):
+    def compare_values_against_list(expected_list, enum):
+      for (idx, val) in enumerate(expected_list):
+        self.assertEquals(val,
+                          enum_calculate_value_string(list(enum.values)[idx]))
+
+    plain_enum = Enum(parent=None, values=['ON', 'OFF'])
+
+    compare_values_against_list(['0', '1'],
+                                plain_enum)
+
+    ###
+    labeled_enum = Enum(parent=None, values=['A', 'B', 'C'], ids={
+      'A': '12345',
+      'B': '0xC0FFEE',
+      'C': '0xDEADF00D'
+    })
+
+    compare_values_against_list(['12345', '0xC0FFEE', '0xDEADF00D'],
+                                labeled_enum)
+
+    ###
+    mixed_enum = Enum(parent=None,
+                      values=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'],
+                      ids={
+                        'C': '0xC0FFEE',
+                        'E': '123',
+                        'G': '0xDEADF00D'
+                      })
+
+    expected_values = ['0', '1', '0xC0FFEE', '0xC0FFEF', '123', '124',
+                       '0xDEADF00D',
+                       '0xDEADF00E']
+
+    compare_values_against_list(expected_values, mixed_enum)
+
+  def test_enumerate_with_last(self):
+    empty_list = []
+
+    for (x, y) in enumerate_with_last(empty_list):
+      self.fail("Should not return anything for empty list")
+
+    single_value = [1]
+    for (x, last) in enumerate_with_last(single_value):
+      self.assertEquals(1, x)
+      self.assertEquals(True, last)
+
+    multiple_values = [4, 5, 6]
+    lst = list(enumerate_with_last(multiple_values))
+    self.assertListEqual([(4, False), (5, False), (6, True)], lst)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/camera/docs/metadata_model.py b/camera/docs/metadata_model.py
index fa85a58e..7db5ffe1 100644
--- a/camera/docs/metadata_model.py
+++ b/camera/docs/metadata_model.py
@@ -23,14 +23,16 @@ metadata_properties.xml file.
   Node: Base class for most nodes.
   Entry: A node corresponding to <entry> elements.
   Clone: A node corresponding to <clone> elements.
+  MergedEntry: A node corresponding to either <entry> or <clone> elements.
   Kind: A node corresponding to <dynamic>, <static>, <controls> elements.
   InnerNamespace: A node corresponding to a <namespace> nested under a <kind>.
   OuterNamespace: A node corresponding to a <namespace> with <kind> children.
   Section: A node corresponding to a <section> element.
   Enum: A class corresponding an <enum> element within an <entry>
-  Value: A class corresponding to a <value> element within an Enum
+  EnumValue: A class corresponding to a <value> element within an Enum
   Metadata: Root node that also provides tree construction functionality.
   Tag: A node corresponding to a top level <tag> element.
+  Typedef: A node corresponding to a <typedef> element under <types>.
 """
 
 import sys
@@ -80,7 +82,6 @@ class Node(object):
       for j in i.find_all(pred):
         yield j
 
-
   def find_first(self, pred):
     """
     Find the first descendant that matches the predicate.
@@ -147,7 +148,7 @@ class Node(object):
 
   def _children_name_map_matching(self, match=lambda x: True):
     d = {}
-    for i in _get_children():
+    for i in self._get_children():
       if match(i):
         d[i.name] = i
     return d
@@ -195,6 +196,7 @@ class Metadata(Node):
     parent: An edge to the parent Node. This is always None for Metadata.
     outer_namespaces: A sequence of immediate OuterNamespace children.
     tags: A sequence of all Tag instances available in the graph.
+    types: An iterable of all Typedef instances available in the graph.
   """
 
   def __init__(self):
@@ -214,6 +216,7 @@ class Metadata(Node):
     self._parent = None
     self._outer_namespaces = None
     self._tags = []
+    self._types = []
 
   @property
   def outer_namespaces(self):
@@ -226,6 +229,10 @@ class Metadata(Node):
   def tags(self):
     return (i for i in self._tags)
 
+  @property
+  def types(self):
+    return (i for i in self._types)
+
   def _get_properties(self):
 
     for i in self._entries:
@@ -253,6 +260,33 @@ class Metadata(Node):
     if not tag_ids:
       self._tags.append(Tag(tag, self, description))
 
+  def insert_type(self, type_name, type_selector="typedef", **kwargs):
+    """
+    Insert a type into the metadata.
+
+    Args:
+      type_name: A type's name
+      type_selector: The selector for the type, e.g. 'typedef'
+
+    Args (if type_selector == 'typedef'):
+      languages: A map of 'language name' -> 'fully qualified class path'
+
+    Example:
+      metadata.insert_type('rectangle', 'typedef',
+                           { 'java': 'android.graphics.Rect' })
+
+    Remarks:
+      Subsequent calls to insert_type with the same type name are safe (they
+      will be ignored)
+    """
+
+    if type_selector != 'typedef':
+      raise ValueError("Unsupported type_selector given " + type_selector)
+
+    type_names = [tp.name for tp in self.types if tp.name == tp]
+    if not type_names:
+      self._types.append(Typedef(type_name, self, kwargs.get('languages')))
+
   def insert_entry(self, entry):
     """
     Insert an entry into the metadata.
@@ -283,7 +317,6 @@ class Metadata(Node):
       (they will be ignored). Also the target entry need not be inserted
       ahead of the clone entry.
     """
-    entry_name = clone['name']
     # figure out corresponding entry later. allow clone insert, entry insert
     entry = None
     c = Clone(entry, **clone)
@@ -310,7 +343,7 @@ class Metadata(Node):
       if p.parent is not None:
         p.parent._entries.remove(p)
       # remove from parents' _leafs list
-      for ancestor in p.find_parents(lambda x: not isinstance(x, MetadataSet)):
+      for ancestor in p.find_parents(lambda x: not isinstance(x, Metadata)):
         ancestor._leafs.remove(p)
 
       # remove from global list
@@ -333,6 +366,8 @@ class Metadata(Node):
     self.validate_tree()
     self._construct_tags()
     self.validate_tree()
+    self._construct_types()
+    self.validate_tree()
     self._construct_clones()
     self.validate_tree()
     self._construct_outer_namespaces()
@@ -351,6 +386,16 @@ class Metadata(Node):
         if p not in tag.entries:
           tag._entries.append(p)
 
+  def _construct_types(self):
+    type_dict = self._dictionary_by_name(self.types)
+    for p in self._get_properties():
+      if p._type_name:
+        type_node = type_dict.get(p._type_name)
+        p._typedef = type_node
+
+        if p not in type_node.entries:
+          type_node._entries.append(p)
+
   def _construct_clones(self):
     for p in self._clones:
       target_kind = p.target_kind
@@ -568,6 +613,36 @@ class Tag(Node):
   def _get_children(self):
     return None
 
+class Typedef(Node):
+  """
+  A typedef Node corresponding to a <typedef> element under a top-level <types>.
+
+  Attributes (Read-Only):
+    name: The name of this typedef as a string.
+    languages: A dictionary of 'language name' -> 'fully qualified class'.
+    parent: An edge to the parent, which is always the Metadata root node.
+    entries: An iterable over all entries which reference this typedef.
+  """
+  def __init__(self, name, parent, languages=None):
+    self._name        = name
+    self._parent      = parent
+
+    # all entries that have this typedef
+    self._entries     = []  # filled in by Metadata#construct_types
+
+    self._languages   = languages or {}
+
+  @property
+  def languages(self):
+    return self._languages
+
+  @property
+  def entries(self):
+    return (i for i in self._entries)
+
+  def _get_children(self):
+    return None
+
 class OuterNamespace(Node):
   """
   A node corresponding to a <namespace> element under <metadata>
@@ -652,6 +727,37 @@ class Section(Node):
     for k in new_kinds_lst:
       yield k
 
+  def combine_kinds_into_single_node(self):
+    r"""
+    Combines the section's Kinds into a single node.
+
+    Combines all the children (kinds) of this section into a single
+    virtual Kind node.
+
+    Returns:
+      A new Kind node that collapses all Kind siblings into one, combining
+      all their children together.
+
+      For example, given self.kinds == [ x, y ]
+
+        x  y               z
+      / |  | \    -->   / | | \
+      a b  c d          a b c d
+
+      a new instance z is returned in this example.
+
+    Remarks:
+      The children of the kinds are the same references as before, that is
+      their parents will point to the old parents and not to the new parent.
+    """
+    combined = Kind(name="combined", parent=self)
+
+    for k in self._get_children():
+      combined._namespaces.extend(k.namespaces)
+      combined._entries.extend(k.entries)
+
+    return combined
+
 class Kind(Node):
   """
   A node corresponding to one of: <static>,<dynamic>,<controls> under a
@@ -695,6 +801,63 @@ class Kind(Node):
     for i in self.entries:
       yield i
 
+  def combine_children_by_name(self):
+    r"""
+    Combine multiple children with the same name into a single node.
+
+    Returns:
+      A new Kind where all of the children with the same name were combined.
+
+      For example:
+
+      Given a Kind k:
+
+              k
+            / | \
+            a b c
+            | | |
+            d e f
+
+      a.name == "foo"
+      b.name == "foo"
+      c.name == "bar"
+
+      The returned Kind will look like this:
+
+             k'
+            /  \
+            a' c'
+          / |  |
+          d e  f
+
+    Remarks:
+      This operation is not recursive. To combine the grandchildren and other
+      ancestors, call this method on the ancestor nodes.
+    """
+    return Kind._combine_children_by_name(self, new_type=type(self))
+
+  # new_type is either Kind or InnerNamespace
+  @staticmethod
+  def _combine_children_by_name(self, new_type):
+    new_ins_dict = OrderedDict()
+    new_ent_dict = OrderedDict()
+
+    for ins in self.namespaces:
+      new_ins = new_ins_dict.setdefault(ins.name,
+                                        InnerNamespace(ins.name, parent=self))
+      new_ins._namespaces.extend(ins.namespaces)
+      new_ins._entries.extend(ins.entries)
+
+    for ent in self.entries:
+      new_ent = new_ent_dict.setdefault(ent.name,
+                                        ent.merge())
+
+    kind = new_type(self.name, self.parent)
+    kind._namespaces = new_ins_dict.values()
+    kind._entries = new_ent_dict.values()
+
+    return kind
+
 class InnerNamespace(Node):
   """
   A node corresponding to a <namespace> which is an ancestor of a Kind.
@@ -737,6 +900,42 @@ class InnerNamespace(Node):
     for i in self.entries:
       yield i
 
+  def combine_children_by_name(self):
+    r"""
+    Combine multiple children with the same name into a single node.
+
+    Returns:
+      A new InnerNamespace where all of the children with the same name were
+      combined.
+
+      For example:
+
+      Given an InnerNamespace i:
+
+              i
+            / | \
+            a b c
+            | | |
+            d e f
+
+      a.name == "foo"
+      b.name == "foo"
+      c.name == "bar"
+
+      The returned InnerNamespace will look like this:
+
+             i'
+            /  \
+            a' c'
+          / |  |
+          d e  f
+
+    Remarks:
+      This operation is not recursive. To combine the grandchildren and other
+      ancestors, call this method on the ancestor nodes.
+    """
+    return Kind._combine_children_by_name(self, new_type=type(self))
+
 class EnumValue(Node):
   """
   A class corresponding to a <value> element within an <enum> within an <entry>.
@@ -777,6 +976,8 @@ class Enum(Node):
   Attributes (Read-Only):
     parent: An edge to the parent, always an Entry instance.
     values: A sequence of EnumValue children.
+    has_values_with_id: A boolean representing if any of the children have a
+        non-empty id property.
   """
   def __init__(self, parent, values, ids={}, optionals=[], notes={}):
     self._values =                                                             \
@@ -790,6 +991,10 @@ class Enum(Node):
   def values(self):
     return (i for i in self._values)
 
+  @property
+  def has_values_with_id(self):
+    return bool(any(i for i in self.values if i.id))
+
   def _get_children(self):
     return (i for i in self._values)
 
@@ -807,6 +1012,17 @@ class Entry(Node):
     container: The container attribute from <entry container="array">, or None.
     container_sizes: A sequence of size strings or None if container is None.
     enum: An Enum instance if the enum attribute is true, None otherwise.
+    visibility: The visibility of this entry ('system', 'hidden', 'public')
+                across the system. System entries are only visible in native code
+                headers. Hidden entries are marked @hide in managed code, while
+                public entries are visible in the Android SDK.
+    applied_visibility: As visibility, but always valid, defaulting to 'system'
+                        if no visibility is given for an entry.
+    optional: a bool representing the optional attribute, which denotes the entry
+              is required for hardware level full devices, but optional for other
+              hardware levels.  None if not present.
+    applied_optional: As optional but always valid, defaulting to False if no
+                      optional attribute is present.
     tuple_values: A sequence of strings describing the tuple values,
                   None if container is not 'tuple'.
     description: A string description, or None.
@@ -814,6 +1030,7 @@ class Entry(Node):
     units: A string units, or None.
     tags: A sequence of Tag nodes associated with this Entry.
     type_notes: A string describing notes for the type, or None.
+    typedef: A Typedef associated with this Entry, or None.
 
   Remarks:
     Subclass Clone can be used interchangeable with an Entry,
@@ -852,6 +1069,10 @@ class Entry(Node):
       notes: A string with the notes for the entry
       tag_ids: A list of tag ID strings, e.g. ['BC', 'V1']
       type_notes: A string with the notes for the type
+      visibility: A string describing the visibility, eg 'system', 'hidden',
+                  'public'
+      optional: A bool to mark whether optional for non-full hardware devices
+      typedef: A string corresponding to a typedef's name attribute.
     """
 
     if kwargs.get('type') is None:
@@ -876,6 +1097,22 @@ class Entry(Node):
     return self._kind
 
   @property
+  def visibility(self):
+    return self._visibility
+
+  @property
+  def applied_visibility(self):
+    return self._visibility or 'system'
+
+  @property
+  def optional(self):
+    return self._optional
+
+  @property
+  def applied_optional(self):
+    return self._optional or False
+
+  @property
   def name_short(self):
     return self.get_name_minimal()
 
@@ -925,6 +1162,10 @@ class Entry(Node):
     return self._type_notes
 
   @property
+  def typedef(self):
+    return self._typedef
+
+  @property
   def enum(self):
     return self._enum
 
@@ -946,7 +1187,7 @@ class Entry(Node):
 
   def _init_common(self, **kwargs):
 
-    self._parent = None # filled in by MetadataSet::_construct_entries
+    self._parent = None # filled in by Metadata::_construct_entries
 
     self._container = kwargs.get('container')
     self._container_sizes = kwargs.get('container_sizes')
@@ -954,8 +1195,8 @@ class Entry(Node):
     # access these via the 'enum' prop
     enum_values = kwargs.get('enum_values')
     enum_optionals = kwargs.get('enum_optionals')
-    enum_notes = kwargs.get('enum_notes') # { value => notes }
-    enum_ids = kwargs.get('enum_ids') # { value => notes }
+    enum_notes = kwargs.get('enum_notes')  # { value => notes }
+    enum_ids = kwargs.get('enum_ids')  # { value => notes }
     self._tuple_values = kwargs.get('tuple_values')
 
     self._description = kwargs.get('description')
@@ -964,15 +1205,20 @@ class Entry(Node):
     self._notes = kwargs.get('notes')
 
     self._tag_ids = kwargs.get('tag_ids', [])
-    self._tags = None # Filled in by MetadataSet::_construct_tags
+    self._tags = None  # Filled in by Metadata::_construct_tags
 
     self._type_notes = kwargs.get('type_notes')
+    self._type_name = kwargs.get('type_name')
+    self._typedef = None # Filled in by Metadata::_construct_types
 
     if kwargs.get('enum', False):
       self._enum = Enum(self, enum_values, enum_ids, enum_optionals, enum_notes)
     else:
       self._enum = None
 
+    self._visibility = kwargs.get('visibility')
+    self._optional = kwargs.get('optional')
+
     self._property_keys = kwargs
 
   def merge(self):
@@ -1106,9 +1352,9 @@ class Clone(Entry):
       Note that type is not specified since it has to be the same as the
       entry.type.
     """
-    self._entry = entry # Entry object
+    self._entry = entry  # Entry object
     self._target_kind = kwargs['target_kind']
-    self._name = kwargs['name'] # same as entry.name
+    self._name = kwargs['name']  # same as entry.name
     self._kind = kwargs['kind']
 
     # illegal to override the type, it should be the same as the entry
@@ -1165,6 +1411,9 @@ class MergedEntry(Entry):
                     'tuple_values',
                     'type',
                     'type_notes',
+                    'visibility',
+                    'optional',
+                    'typedef'
                    ]
 
     for p in props_common:
diff --git a/camera/docs/metadata_model_test.py b/camera/docs/metadata_model_test.py
new file mode 100644
index 00000000..eb79c9ba
--- /dev/null
+++ b/camera/docs/metadata_model_test.py
@@ -0,0 +1,130 @@
+import unittest
+from unittest import TestCase
+from metadata_model import *
+
+class TestInnerNamespace(TestCase):
+  def test_combine_children_by_name(self):
+    #
+    # Set up
+    #
+    kind = Kind("some_root_kind", parent=None)
+    ins_outer = InnerNamespace("static", parent=kind)
+    kind._namespaces = [ins_outer]
+
+    ins1 = InnerNamespace("ins1", parent=ins_outer)
+    ins1a = InnerNamespace("ins1", parent=ins_outer)  # same name deliberately
+    entry1 = Entry(name="entry1", type="int32", kind="static",
+                   parent=ins1)
+    entry2 = Entry(name="entry2", type="int32", kind="static",
+                   parent=ins1a)
+    entry3 = Entry(name="entry3", type="int32", kind="static",
+                   parent=ins_outer)
+
+    ins_outer._namespaces = [ins1, ins1a]
+    ins_outer._entries = [entry3]
+
+    ins1._entries = [entry1]
+    ins1a._entries = [entry2]
+
+    #
+    # Test
+    #
+    combined_children_namespace = ins_outer.combine_children_by_name()
+
+    self.assertIsInstance(combined_children_namespace, InnerNamespace)
+    combined_ins = [i for i in combined_children_namespace.namespaces]
+    combined_ent = [i for i in combined_children_namespace.entries]
+
+    self.assertEquals(kind, combined_children_namespace.parent)
+    self.assertEquals(1, len(combined_ins))
+    self.assertEquals(1, len(combined_ent))
+
+    self.assertEquals("ins1", combined_ins[0].name)
+    self.assertEquals("entry3", combined_ent[0].name)
+
+    new_ins = combined_ins[0]
+    self.assertIn(entry1, new_ins.entries)
+    self.assertIn(entry2, new_ins.entries)
+
+
+class TestKind(TestCase):
+  def test_combine_kinds_into_single_node(self):
+    #
+    # Set up
+    #
+    section = Section("some_section", parent=None)
+    kind_static = Kind("static", parent=section)
+    kind_dynamic = Kind("dynamic", parent=section)
+    section._kinds = [kind_static, kind_dynamic]
+
+    ins1 = InnerNamespace("ins1", parent=kind_static)
+    ins2 = InnerNamespace("ins2", parent=kind_dynamic)
+    entry1 = Entry(name="entry1", type="int32", kind="static",
+                   parent=kind_static)
+    entry2 = Entry(name="entry2", type="int32", kind="static",
+                   parent=kind_dynamic)
+
+    kind_static._namespaces = [ins1]
+    kind_static._entries = [entry1]
+
+    kind_dynamic._namespaces = [ins2]
+    kind_dynamic._entries = [entry2]
+
+    #
+    # Test
+    #
+    combined_kind = section.combine_kinds_into_single_node()
+
+    self.assertEquals(section, combined_kind.parent)
+
+    self.assertIn(ins1, combined_kind.namespaces)
+    self.assertIn(ins2, combined_kind.namespaces)
+
+    self.assertIn(entry1, combined_kind.entries)
+    self.assertIn(entry2, combined_kind.entries)
+
+  def test_combine_children_by_name(self):
+    #
+    # Set up
+    #
+    section = Section("some_section", parent=None)
+    kind_static = Kind("static", parent=section)
+    section._kinds = [kind_static]
+
+    ins1 = InnerNamespace("ins1", parent=kind_static)
+    ins1a = InnerNamespace("ins1", parent=kind_static)  # same name deliberately
+    entry1 = Entry(name="entry1", type="int32", kind="static",
+                   parent=ins1)
+    entry2 = Entry(name="entry2", type="int32", kind="static",
+                   parent=ins1a)
+    entry3 = Entry(name="entry3", type="int32", kind="static",
+                   parent=kind_static)
+
+    kind_static._namespaces = [ins1, ins1a]
+    kind_static._entries = [entry3]
+
+    ins1._entries = [entry1]
+    ins1a._entries = [entry2]
+
+    #
+    # Test
+    #
+    combined_children_kind = kind_static.combine_children_by_name()
+
+    self.assertIsInstance(combined_children_kind, Kind)
+    combined_ins = [i for i in combined_children_kind.namespaces]
+    combined_ent = [i for i in combined_children_kind.entries]
+
+    self.assertEquals(section, combined_children_kind.parent)
+    self.assertEquals(1, len(combined_ins))
+    self.assertEquals(1, len(combined_ent))
+
+    self.assertEquals("ins1", combined_ins[0].name)
+    self.assertEquals("entry3", combined_ent[0].name)
+
+    new_ins = combined_ins[0]
+    self.assertIn(entry1, new_ins.entries)
+    self.assertIn(entry2, new_ins.entries)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/camera/docs/metadata_parser_xml.py b/camera/docs/metadata_parser_xml.py
index 7b552738..ec6957f2 100755
--- a/camera/docs/metadata_parser_xml.py
+++ b/camera/docs/metadata_parser_xml.py
@@ -107,6 +107,15 @@ class MetadataParserXml:
       for tag in tags.find_all('tag'):
         self.metadata.insert_tag(tag['id'], tag.string)
 
+    types = self.soup.types
+    if types is not None:
+      for tp in types.find_all('typedef'):
+        languages = {}
+        for lang in tp.find_all('language'):
+          languages[lang['name']] = lang.string
+
+        self.metadata.insert_type(tp['name'], 'typedef', languages=languages)
+
     # add all entries, preserving the ordering of the XML file
     # this is important for future ABI compatibility when generating code
     entry_filter = lambda x: x.name == 'entry' or x.name == 'clone'
@@ -144,6 +153,21 @@ class MetadataParserXml:
     d = {}
 
     #
+    # Visibility
+    #
+    d['visibility'] = entry.get('visibility')
+
+    #
+    # Optional for non-full hardware level devices
+    #
+    d['optional'] = entry.get('optional') == 'true'
+
+    #
+    # Typedef
+    #
+    d['type_name'] = entry.get('typedef')
+
+    #
     # Enum
     #
     if entry.get('enum', 'false') == 'true':
diff --git a/camera/docs/metadata_properties.xml b/camera/docs/metadata_properties.xml
index 2980c8d6..3e898c62 100644
--- a/camera/docs/metadata_properties.xml
+++ b/camera/docs/metadata_properties.xml
@@ -36,15 +36,40 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     <tag id="EXIF">
       <!-- TODO: fill the tag description -->
     </tag>
+    <tag id="HAL2">
+        Entry is only used by camera device HAL 2.x
+    </tag>
+    <tag id="FULL">
+        Entry is required for full hardware level devices, and optional for other hardware levels
+    </tag>
   </tags>
+
+  <types>
+    <typedef name="rectangle">
+      <language name="java">android.graphics.Rect</language>
+    </typedef>
+    <typedef name="size">
+      <language name="java">android.hardware.camera2.Size</language>
+    </typedef>
+    <typedef name="string">
+      <language name="java">String</language>
+    </typedef>
+    <typedef name="boolean">
+      <language name="java">boolean</language>
+    </typedef>
+    <typedef name="imageFormat">
+      <language name="java">int</language>
+    </typedef>
+  </types>
+
   <namespace name="android">
     <section name="colorCorrection">
       <controls>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>TRANSFORM_MATRIX
               <notes>Use the android.colorCorrection.transform matrix
-              to do color conversion</notes>
+              and android.colorCorrection.gains to do color conversion</notes>
             </value>
             <value>FAST
               <notes>Must not slow down frame rate relative to raw
@@ -55,34 +80,67 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
               quality</notes>
             </value>
           </enum>
+
+          <notes>When android.control.awbMode is not OFF, TRANSFORM_MATRIX
+          should be ignored.</notes>
         </entry>
-        <entry name="transform" type="float"
-        type_notes="3x3 float matrix in row-major order"
-        container="array">
+        <entry name="transform" type="rational" visibility="public"
+               type_notes="3x3 rational matrix in row-major order"
+               container="array">
           <array>
             <size>3</size>
             <size>3</size>
           </array>
-          <description>A transform matrix to chromatically adapt
-          pixels in the CIE XYZ (1931) color space from the scene
-          illuminant to the sRGB-standard
-          D65-illuminant</description>
+          <description>A color transform matrix to use to transform
+          from sensor RGB color space to output linear sRGB color space
+          </description>
           <range>Output values are expected to be in the range
           (0,1)</range>
-          <notes>Values outside (0,1) should be clamped. Need to
-          provide utilities to go from CCT (+hue?), or (x,y) white
-          point, (or AWB mode) to matrix; use linear Bradford
-          algorithm.</notes>
+          <notes>This matrix is either set by HAL when the request
+          android.colorCorrection.mode is not TRANSFORM_MATRIX, or
+          directly by the application in the request when the
+          android.colorCorrection.mode is TRANSFORM_MATRIX.
+
+          In the latter case, the HAL may round the matrix to account
+          for precision issues; the final rounded matrix should be
+          reported back in this matrix result metadata.</notes>
+        </entry>
+        <entry name="gains" type="float" visibility="public"
+               type_notes="A 1D array of floats for 4 color channel gains"
+               container="array">
+          <array>
+            <size>4</size>
+          </array>
+          <description>Gains applying to Bayer color channels for
+          white-balance</description>
+          <notes>The 4-channel white-balance gains are defined in
+          the order of [R G_even G_odd B], where G_even is the gain
+          for green pixels on even rows of the output, and G_odd
+          is the gain for greenpixels on the odd rows. if a HAL
+          does not support a separate gain for even/odd green channels,
+          it should use the G_even value,and write G_odd equal to
+          G_even in the output result metadata.
+
+          This array is either set by HAL when the request
+          android.colorCorrection.mode is not TRANSFORM_MATRIX, or
+          directly by the application in the request when the
+          android.colorCorrection.mode is TRANSFORM_MATRIX.
+
+          The ouput should be the gains actually applied by the HAL to
+          the current frame.</notes>
         </entry>
       </controls>
       <dynamic>
-        <clone entry="android.colorCorrection.mode"
-        kind="controls"></clone>
+        <clone entry="android.colorCorrection.transform" kind="controls">
+        </clone>
+        <clone entry="android.colorCorrection.gains" kind="controls">
+        </clone>
       </dynamic>
     </section>
     <section name="control">
       <controls>
-        <entry name="aeAntibandingMode" type="byte" enum="true">
+        <entry name="aeAntibandingMode" type="byte" visibility="public"
+               enum="true" >
           <enum>
             <value>OFF</value>
             <value>50HZ</value>
@@ -94,7 +152,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>
           android.control.aeAvailableAntibandingModes</range>
         </entry>
-        <entry name="aeExposureCompensation" type="int32">
+        <entry name="aeExposureCompensation" type="int32" visibility="public">
           <description>Adjustment to AE target image
           brightness</description>
           <units>count of positive/negative EV steps</units>
@@ -103,7 +161,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           compensation of -1</notes>
           <tag id="BC" />
         </entry>
-        <entry name="aeLock" type="byte" enum="true">
+        <entry name="aeLock" type="byte" visibility="public" enum="true"
+               typedef="boolean">
           <enum>
             <value>OFF
             <notes>Autoexposure lock is disabled; the AE algorithm
@@ -120,11 +179,11 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           ON_AUTO_FLASH_REDEYE.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="aeMode" type="byte" enum="true">
+        <entry name="aeMode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
-              <notes>Autoexposure is disabled; sensor.exposureTime
-              and sensor.sensitivity are used</notes>
+              <notes>Autoexposure is disabled; sensor.exposureTime,
+              sensor.sensitivity and sensor.frameDuration are used</notes>
             </value>
             <value>ON
               <notes>Autoexposure is active, no flash
@@ -153,7 +212,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           AUTO</notes>
           <tag id="BC" />
         </entry>
-        <entry name="aeRegions" type="int32" container="array">
+        <entry name="aeRegions" type="int32" visibility="public"
+               container="array">
           <array>
             <size>5</size>
             <size>area_count</size>
@@ -161,22 +221,25 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>List of areas to use for
           metering</description>
           <notes>Each area is a rectangle plus weight: xmin, ymin,
-          xmax, ymax, weight. The coordinate system is based on the
-          active pixel array, with (0,0) being the top-left of the
-          active pixel array, and
-          (android.sensor.info.activeArraySize.width,
-          android.sensor.info.activeArraySize.height) being the
-          bottom-right point of the active pixel array. The weight
-          should be nonnegative. If all regions have 0 weight, then
-          no specific metering area needs to be used by the HAL. If
-          the metering region is outside the current
-          android.scaler.cropRegion, the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata</notes>
+          xmax, ymax, weight. The rectangle is defined inclusive of the
+          specified coordinates.
+
+          The coordinate system is based on the active pixel array,
+          with (0,0) being the top-left pixel in the active pixel array, and
+          (android.sensor.info.activeArraySize.width - 1,
+          android.sensor.info.activeArraySize.height - 1) being the
+          bottom-right pixel in the active pixel array. The weight
+          should be nonnegative.
+
+          If all regions have 0 weight, then no specific metering area
+          needs to be used by the HAL. If the metering region is
+          outside the current android.scaler.cropRegion, the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata</notes>
           <tag id="BC" />
         </entry>
-        <entry name="aeTargetFpsRange" type="int32"
-        container="array">
+        <entry name="aeTargetFpsRange" type="int32" visibility="public"
+               container="array">
           <array>
             <size>2</size>
           </array>
@@ -187,7 +250,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           of android.sensor.exposureTime</notes>
           <tag id="BC" />
         </entry>
-        <entry name="aePrecaptureTrigger" type="byte" enum="true">
+        <entry name="aePrecaptureTrigger" type="byte" visibility="public"
+               enum="true">
           <enum>
             <value>IDLE
               <notes>The trigger is idle.</notes>
@@ -204,70 +268,79 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>This entry is normally set to IDLE, or is not
           included at all in the request settings. When included and
           set to START, the HAL must trigger the autoexposure
-          precapture metering sequence. The effect of AE precapture
-          trigger depends on the current AE mode and state; see the
-          camera HAL device v3 header for details.</notes>
+          precapture metering sequence.
+
+          The effect of AE precapture trigger depends on the current
+          AE mode and state; see the camera HAL device v3 header for
+          details.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="afMode" type="byte" enum="true">
+        <entry name="afMode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
             <notes>The 3A routines do not control the lens;
-            android.lens.focusPosition is controlled by the
+            android.lens.focusDistance is controlled by the
             application</notes></value>
             <value>AUTO
-            <notes>if lens is not fixed focus. Use
-            android.lens.minimumFocusDistance to determine if lens
-            is fixed focus In this mode, the lens does not move
-            unless the autofocus trigger action is called. When
-            that trigger is activated, AF must transition to
-            ACTIVE_SCAN, then to the outcome of the scan (FOCUSED
-            or NOT_FOCUSED). Triggering cancel AF resets the lens
-            position to default, and sets the AF state to
-            INACTIVE.</notes></value>
+            <notes>if lens is not fixed focus.
+
+            Use android.lens.minimumFocusDistance to determine if lens
+            is fixed focus In this mode, the lens does not move unless
+            the autofocus trigger action is called. When that trigger
+            is activated, AF must transition to ACTIVE_SCAN, then to
+            the outcome of the scan (FOCUSED or
+            NOT_FOCUSED).
+
+            Triggering cancel AF resets the lens position to default,
+            and sets the AF state to INACTIVE.</notes></value>
             <value>MACRO
             <notes>In this mode, the lens does not move unless the
-            autofocus trigger action is called. When that trigger
-            is activated, AF must transition to ACTIVE_SCAN, then
-            to the outcome of the scan (FOCUSED or NOT_FOCUSED).
-            Triggering cancel AF resets the lens position to
-            default, and sets the AF state to
+            autofocus trigger action is called.
+
+            When that trigger is activated, AF must transition to
+            ACTIVE_SCAN, then to the outcome of the scan (FOCUSED or
+            NOT_FOCUSED).  Triggering cancel AF resets the lens
+            position to default, and sets the AF state to
             INACTIVE.</notes></value>
             <value>CONTINUOUS_VIDEO
             <notes>In this mode, the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream. The focusing behavior
-            should be suitable for good quality video recording;
-            typically this means slower focus movement and no
-            overshoots. When the AF trigger is not involved, the AF
-            algorithm should start in INACTIVE state, and then
-            transition into PASSIVE_SCAN and PASSIVE_FOCUSED states
-            as appropriate. When the AF trigger is activated, the
-            algorithm should immediately transition into AF_FOCUSED
-            or AF_NOT_FOCUSED as appropriate, and lock the lens
-            position until a cancel AF trigger is received. Once
-            cancel is received, the algorithm should transition
-            back to INACTIVE and resume passive scan. Note that
-            this behavior is not identical to CONTINUOUS_PICTURE,
-            since an ongoing PASSIVE_SCAN must immediately be
+            constantly-in-focus image stream.
+
+            The focusing behavior should be suitable for good quality
+            video recording; typically this means slower focus
+            movement and no overshoots. When the AF trigger is not
+            involved, the AF algorithm should start in INACTIVE state,
+            and then transition into PASSIVE_SCAN and PASSIVE_FOCUSED
+            states as appropriate. When the AF trigger is activated,
+            the algorithm should immediately transition into
+            AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the
+            lens position until a cancel AF trigger is received.
+
+            Once cancel is received, the algorithm should transition
+            back to INACTIVE and resume passive scan. Note that this
+            behavior is not identical to CONTINUOUS_PICTURE, since an
+            ongoing PASSIVE_SCAN must immediately be
             canceled.</notes></value>
             <value>CONTINUOUS_PICTURE
             <notes>In this mode, the AF algorithm modifies the lens
             position continually to attempt to provide a
-            constantly-in-focus image stream. The focusing behavior
-            should be suitable for still image capture; typically
-            this means focusing as fast as possible. When the AF
-            trigger is not involved, the AF algorithm should start
-            in INACTIVE state, and then transition into
-            PASSIVE_SCAN and PASSIVE_FOCUSED states as appropriate
-            as it attempts to maintain focus. When the AF trigger
-            is activated, the algorithm should finish its
+            constantly-in-focus image stream.
+
+            The focusing behavior should be suitable for still image
+            capture; typically this means focusing as fast as
+            possible. When the AF trigger is not involved, the AF
+            algorithm should start in INACTIVE state, and then
+            transition into PASSIVE_SCAN and PASSIVE_FOCUSED states as
+            appropriate as it attempts to maintain focus. When the AF
+            trigger is activated, the algorithm should finish its
             PASSIVE_SCAN if active, and then transition into
-            AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock
-            the lens position until a cancel AF trigger is
-            received. When the AF cancel trigger is activated, the
-            algorithm should transition back to INACTIVE and then
-            act as if it has just been started.</notes></value>
+            AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the
+            lens position until a cancel AF trigger is received.
+
+            When the AF cancel trigger is activated, the algorithm
+            should transition back to INACTIVE and then act as if it
+            has just been started.</notes></value>
             <value>EDOF
             <notes>Extended depth of field (digital focus). AF
             trigger is ignored, AF state should always be
@@ -277,7 +350,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           mode it is set to</description>
           <tag id="BC" />
         </entry>
-        <entry name="afRegions" type="int32" container="array">
+        <entry name="afRegions" type="int32" visibility="public"
+               container="array">
           <array>
             <size>5</size>
             <size>area_count</size>
@@ -285,21 +359,24 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>List of areas to use for focus
           estimation</description>
           <notes>Each area is a rectangle plus weight: xmin, ymin,
-          xmax, ymax, weight. The coordinate system is based on the
-          active pixel array, with (0,0) being the top-left of the
-          active pixel array, and
-          (android.sensor.info.activeArraySize.width,
-          android.sensor.info.activeArraySize.height) being the
-          bottom-right point of the active pixel array. The weight
-          should be nonnegative. If all regions have 0 weight, then
-          no specific focus area needs to be used by the HAL. If
-          the focusing region is outside the current
-          android.scaler.cropRegion, the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata</notes>
+          xmax, ymax, weight. The rectangle is defined inclusive of the
+          specified coordinates.
+
+          The coordinate system is based on the active pixel array,
+          with (0,0) being the top-left pixel in the active pixel array, and
+          (android.sensor.info.activeArraySize.width - 1,
+          android.sensor.info.activeArraySize.height - 1) being the
+          bottom-right pixel in the active pixel array. The weight
+          should be nonnegative.
+
+          If all regions have 0 weight, then no specific focus area
+          needs to be used by the HAL. If the focusing region is
+          outside the current android.scaler.cropRegion, the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata</notes>
           <tag id="BC" />
         </entry>
-        <entry name="afTrigger" type="byte" enum="true">
+        <entry name="afTrigger" type="byte" visibility="public" enum="true">
           <enum>
             <value>IDLE
               <notes>The trigger is idle.</notes>
@@ -314,15 +391,17 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           </enum>
           <description>Whether the HAL must trigger autofocus.</description>
           <notes>This entry is normally set to IDLE, or is not
-          included at all in the request settings. When included and
-          set to START, the HAL must trigger the autofocus
-          algorithm. The effect of AF trigger depends on the current
-          AF mode and state; see the camera HAL device v3 header for
-          details. When set to CANCEL, the HAL must cancel any active
-          trigger, and return to initial AF state.</notes>
+          included at all in the request settings.
+
+          When included and set to START, the HAL must trigger the
+          autofocus algorithm. The effect of AF trigger depends on the
+          current AF mode and state; see the camera HAL device v3
+          header for details. When set to CANCEL, the HAL must cancel
+          any active trigger, and return to initial AF state.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="awbLock" type="byte" enum="true">
+        <entry name="awbLock" type="byte" visibility="public" enum="true"
+               typedef="boolean">
           <enum>
             <value>OFF
             <notes>Auto-whitebalance lock is disabled; the AWB
@@ -340,7 +419,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           setting</notes>
           <tag id="BC" />
         </entry>
-        <entry name="awbMode" type="byte" enum="true">
+        <entry name="awbMode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF</value>
             <value>AUTO</value>
@@ -359,29 +438,35 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <tag id="BC" />
           <tag id="AWB" />
         </entry>
-        <entry name="awbRegions" type="int32" container="array">
+        <entry name="awbRegions" type="int32" visibility="public"
+               container="array">
           <array>
             <size>5</size>
             <size>area_count</size>
           </array>
           <description>List of areas to use for illuminant
           estimation</description>
-          <notes>Only used in AUTO mode. Each area is a rectangle
-          plus weight: xmin, ymin, xmax, ymax, weight. The
-          coordinate system is based on the active pixel array,
-          with (0,0) being the top-left of the active pixel array,
-          and (android.sensor.info.activeArraySize.width,
-          android.sensor.info.activeArraySize.height) being the
-          bottom-right point of the active pixel array. The weight
-          should be nonnegative. If all regions have 0 weight, then
-          no specific metering area needs to be used by the HAL. If
-          the metering region is outside the current
-          android.scaler.cropRegion, the HAL should ignore the
-          sections outside the region and output the used sections
-          in the frame metadata</notes>
+          <notes>Only used in AUTO mode.
+
+          Each area is a rectangle plus weight: xmin, ymin,
+          xmax, ymax, weight. The rectangle is defined inclusive of the
+          specified coordinates.
+
+          The coordinate system is based on the active pixel array,
+          with (0,0) being the top-left pixel in the active pixel array, and
+          (android.sensor.info.activeArraySize.width - 1,
+          android.sensor.info.activeArraySize.height - 1) being the
+          bottom-right pixel in the active pixel array. The weight
+          should be nonnegative.
+
+          If all regions have 0 weight, then no specific metering area
+          needs to be used by the HAL. If the metering region is
+          outside the current android.scaler.cropRegion, the HAL
+          should ignore the sections outside the region and output the
+          used sections in the frame metadata</notes>
           <tag id="BC" />
         </entry>
-        <entry name="captureIntent" type="byte" enum="true">
+        <entry name="captureIntent" type="byte" visibility="public" enum="true">
           <enum>
             <value>CUSTOM
             <notes>This request doesn't fall into the other
@@ -413,7 +498,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>Only used if android.control.mode != OFF.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="effectMode" type="byte" enum="true">
+        <entry name="effectMode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF</value>
             <value optional="true">MONO</value>
@@ -430,7 +515,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>android.control.availableEffects</range>
           <tag id="BC" />
         </entry>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
             <notes>Full application control of pipeline. All 3A
@@ -455,7 +540,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>all must be supported</range>
           <tag id="BC" />
         </entry>
-        <entry name="sceneMode" type="byte" enum="true">
+        <entry name="sceneMode" type="byte" visibility="public" enum="true">
           <enum>
             <value id="0">UNSUPPORTED</value>
             <value>FACE_PRIORITY
@@ -463,10 +548,12 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             detection data to drive 3A routines. If face detection
             statistics are disabled, should still operate correctly
             (but not return face detection statistics to the
-            framework). Unlike the other scene modes, aeMode,
-            awbMode, and afMode remain active when FACE_PRIORITY is
-            set. This is due to compatibility concerns with the old
-            camera API</notes></value>
+            framework).
+
+            Unlike the other scene modes, aeMode, awbMode, and afMode
+            remain active when FACE_PRIORITY is set. This is due to
+            compatibility concerns with the old camera
+            API</notes></value>
             <value optional="true">ACTION</value>
             <value optional="true">PORTRAIT</value>
             <value optional="true">LANDSCAPE</value>
@@ -488,7 +575,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>android.control.availableSceneModes</range>
           <tag id="BC" />
         </entry>
-        <entry name="videoStabilizationMode" type="byte" enum="true">
+        <entry name="videoStabilizationMode" type="byte" visibility="public"
+               enum="true" typedef="boolean">
           <enum>
             <value>OFF</value>
             <value>ON</value>
@@ -502,8 +590,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </controls>
       <static>
-        <entry name="aeAvailableAntibandingModes" type="byte"
-        type_notes="list of enums" container="array">
+        <entry name="aeAvailableAntibandingModes" type="byte" visibility="public"
+               type_notes="list of enums" container="array">
           <array>
             <size>n</size>
           </array>
@@ -521,9 +609,9 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           ON_AUTO_FLASH/ON_ALWAYS_FLASH must be supported if flash
           unit is available</range>
         </entry>
-        <entry name="aeAvailableTargetFpsRanges" type="int32"
-        type_notes="list of pairs of frame rates"
-        container="array">
+        <entry name="aeAvailableTargetFpsRanges" type="int32" visibility="public"
+               type_notes="list of pairs of frame rates"
+               container="array">
           <array>
             <size>2</size>
             <size>n</size>
@@ -531,8 +619,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>List of frame rate ranges supported by the
           AE algorithm/hardware</description>
         </entry>
-        <entry name="aeCompensationRange" type="int32"
-        container="array">
+        <entry name="aeCompensationRange" type="int32" visibility="public"
+               container="array">
           <array>
             <size>2</size>
           </array>
@@ -543,13 +631,13 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           size)</range>
           <tag id="BC" />
         </entry>
-        <entry name="aeCompensationStep" type="rational">
+        <entry name="aeCompensationStep" type="rational" visibility="public">
           <description>Smallest step by which exposure compensation
           can be changed</description>
           <range>&lt;= 1/2</range>
           <tag id="BC" />
         </entry>
-        <entry name="afAvailableModes" type="byte"
+        <entry name="afAvailableModes" type="byte" visibility="public"
         type_notes="List of enums" container="array">
           <array>
             <size>n</size>
@@ -560,8 +648,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           lens allows for changing focus</range>
           <tag id="BC" />
         </entry>
-        <entry name="availableEffects" type="byte"
-        type_notes="list of enums" container="array">
+        <entry name="availableEffects" type="byte" visibility="public"
+               type_notes="list of enums" container="array">
           <array>
             <size>n</size>
           </array>
@@ -570,9 +658,9 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>OFF must be listed</range>
           <tag id="BC" />
         </entry>
-        <entry name="availableSceneModes" type="byte"
-        type_notes="list of enums from android.control.sceneMode, plus UNSUPPORTED to indicate no scene modes are supported"
-        container="array">
+        <entry name="availableSceneModes" type="byte" visibility="public"
+               type_notes="list of enums from android.control.sceneMode, plus UNSUPPORTED to indicate no scene modes are supported"
+               container="array">
           <array>
             <size>n</size>
           </array>
@@ -583,7 +671,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <tag id="BC" />
         </entry>
         <entry name="availableVideoStabilizationModes" type="byte"
-        type_notes="List of enums." container="array">
+               visibility="public" type_notes="List of enums." container="array">
           <array>
             <size>n</size>
           </array>
@@ -592,55 +680,59 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>OFF must be included</range>
           <tag id="BC" />
         </entry>
-        <entry name="awbAvailableModes" type="byte"
-        type_notes="List of enums (android.control.awbMode)"
-        container="array">
+        <entry name="awbAvailableModes" type="byte" visibility="public"
+               type_notes="List of enums (android.control.awbMode)"
+               container="array">
           <array>
             <size>n</size>
           </array>
           <range>OFF, AUTO must be included</range>
           <tag id="BC" />
         </entry>
-        <entry name="maxRegions" type="int32">
+        <entry name="maxRegions" type="int32" visibility="public">
           <description>For AE, AWB, and AF, how many individual
           regions can be listed for metering?</description>
           <range>&gt;= 1</range>
           <tag id="BC" />
         </entry>
-        <entry name="sceneModeOverrides" type="byte"
-        container="array">
+        <entry name="sceneModeOverrides" type="byte" visibility="system"
+               container="array">
           <array>
             <size>3</size>
-            <size>lengthavailablescenemodes</size>
+            <size>length(availableSceneModes)</size>
           </array>
           <description>List of AE, AWB, and AF modes to use for
           each available scene mode</description>
           <range>For each listed scene mode, lists the aeMode,
           awbMode, and afMode that the HAL wants to use for that
-          scene mode. For each entry, the order is {aeMode,
-          awbMode, afMode} in order of increasing index</range>
+          scene mode.
+
+          For each entry, the order is {aeMode, awbMode, afMode} in
+          order of increasing index</range>
           <notes>When a scene mode is enabled, the HAL is expected
           to override aeMode, awbMode, and afMode with its
-          preferred settings for that scene mode. To simplify
-          communication with old camera API applications, the
-          service wants this override list in the static metadata.
-          The order of this list matches that of
-          availableSceneModes, with 3 entires for each scene mode.
-          The overrides listed for SCENE_MODE_FACE_PRIORITY are
-          ignored, since for that mode, the application-set aeMode,
-          awbMode, and afMode are used instead, like they are when
-          android.control.mode is AUTO. It is recommended that for
-          FACE_PRIORITY, the overrides should be set to 0. As an
-          example, if availableSceneModes is { FACE_PRIORITY,
-          ACTION, NIGHT }, then the service expects this field to
-          have 9 entries; for example { 0 , 0, 0, ON_AUTO_FLASH,
-          AUTO, CONTINUOUS_PICTURE, ON_AUTO_FLASH, INCANDESCENT,
-          AUTO }</notes>
+          preferred settings for that scene mode.
+
+          To simplify communication with old camera API applications,
+          the service wants this override list in the static metadata.
+          The order of this list matches that of availableSceneModes,
+          with 3 entires for each scene mode.  The overrides listed
+          for SCENE_MODE_FACE_PRIORITY are ignored, since for that
+          mode, the application-set aeMode, awbMode, and afMode are
+          used instead, like they are when android.control.mode is
+          AUTO.
+
+          It is recommended that for FACE_PRIORITY, the overrides
+          should be set to 0. As an example, if availableSceneModes is
+          { FACE_PRIORITY, ACTION, NIGHT }, then the service expects
+          this field to have 9 entries; for example { 0 , 0, 0,
+          ON_AUTO_FLASH, AUTO, CONTINUOUS_PICTURE, ON_AUTO_FLASH,
+          INCANDESCENT, AUTO }</notes>
           <tag id="BC" />
         </entry>
       </static>
       <dynamic>
-        <entry name="aePrecaptureId" type="int32">
+        <entry name="aePrecaptureId" type="int32" visibility="hidden">
           <description>The ID sent with the latest
           CAMERA2_TRIGGER_PRECAPTURE_METERING call</description>
           <notes>Must be 0 if no
@@ -650,7 +742,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
         <clone entry="android.control.aeRegions" kind="controls">
         </clone>
-        <entry name="aeState" type="byte" enum="true">
+        <entry name="aeState" type="byte" visibility="public" enum="true">
           <enum>
             <value>INACTIVE
             <notes>AE is off.  When a camera device is opened, it starts in
@@ -685,39 +777,43 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </clone>
         <clone entry="android.control.afRegions" kind="controls">
         </clone>
-        <entry name="afState" type="byte" enum="true">
+        <entry name="afState" type="byte" visibility="public" enum="true">
           <enum>
             <value>INACTIVE
             <notes>AF off or has not yet tried to scan/been asked
             to scan.  When a camera device is opened, it starts in
             this state.</notes></value>
             <value>PASSIVE_SCAN
-            <notes>if CONTINUOUS_* modes are supported AF is
+            <notes>if CONTINUOUS_* modes are supported. AF is
             currently doing an AF scan initiated by a continuous
             autofocus mode</notes></value>
             <value>PASSIVE_FOCUSED
-            <notes>if CONTINUOUS_* modes are supported AF currently
+            <notes>if CONTINUOUS_* modes are supported. AF currently
             believes it is in focus, but may restart scanning at
             any time.</notes></value>
             <value>ACTIVE_SCAN
-            <notes>if AUTO or MACRO modes are supported AF is doing
+            <notes>if AUTO or MACRO modes are supported. AF is doing
             an AF scan because it was triggered by AF
             trigger</notes></value>
             <value>FOCUSED_LOCKED
-            <notes>if any AF mode besides OFF is supported AF
+            <notes>if any AF mode besides OFF is supported. AF
             believes it is focused correctly and is
             locked</notes></value>
             <value>NOT_FOCUSED_LOCKED
-            <notes>if any AF mode besides OFF is supported AF has
+            <notes>if any AF mode besides OFF is supported. AF has
             failed to focus successfully and is
             locked</notes></value>
+            <value>PASSIVE_UNFOCUSED
+            <notes>if CONTINUOUS_* modes are supported. AF finished a
+            passive scan without finding focus, and may restart
+            scanning at any time.</notes></value>
           </enum>
           <description>Current state of AF algorithm</description>
           <notes>Whenever the AF algorithm state changes, a
           MSG_AUTOFOCUS notification must be send if a notification
           callback is registered.</notes>
         </entry>
-        <entry name="afTriggerId" type="int32">
+        <entry name="afTriggerId" type="int32" visibility="hidden">
           <description>The ID sent with the latest
           CAMERA2_TRIGGER_AUTOFOCUS call</description>
           <notes>Must be 0 if no CAMERA2_TRIGGER_AUTOFOCUS trigger
@@ -728,7 +824,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </clone>
         <clone entry="android.control.awbRegions" kind="controls">
         </clone>
-        <entry name="awbState" type="byte" enum="true">
+        <entry name="awbState" type="byte" visibility="public" enum="true">
           <enum>
             <value>INACTIVE
             <notes>AWB is not in auto mode.  When a camera device is opened, it
@@ -771,7 +867,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="edge">
       <controls>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
             <notes>No edge enhancement is applied</notes></value>
@@ -815,7 +911,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           duration).</notes>
           <tag id="V1" />
         </entry>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
             <notes>Do not fire the flash for this
@@ -835,7 +931,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
       </controls>
       <static>
         <namespace name="info">
-          <entry name="available" type="byte">
+          <entry name="available" type="byte" visibility="public">
             <description>Whether this camera has a
             flash</description>
             <units>boolean (0 = false, otherwise true)</units>
@@ -874,7 +970,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         <clone entry="android.flash.firingTime" kind="controls">
         </clone>
         <clone entry="android.flash.mode" kind="controls"></clone>
-        <entry name="state" type="byte" enum="true">
+        <entry name="state" type="byte" visibility="public" enum="true">
           <enum>
             <value>UNAVAILABLE
             <notes>No flash on camera</notes></value>
@@ -961,7 +1057,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="jpeg">
       <controls>
-        <entry name="gpsCoordinates" type="double"
+        <entry name="gpsCoordinates" type="double" visibility="public"
         type_notes="latitude, longitude, altitude. First two in degrees, the third in meters"
         container="array">
           <array>
@@ -972,39 +1068,41 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>(-180 - 180], [-90,90], [-inf, inf]</range>
           <tag id="BC" />
         </entry>
-        <entry name="gpsProcessingMethod" type="byte">
+        <entry name="gpsProcessingMethod" type="byte" visibility="public"
+               typedef="string">
           <description>32 characters describing GPS algorithm to
           include in EXIF</description>
           <units>UTF-8 null-terminated string</units>
           <tag id="BC" />
         </entry>
-        <entry name="gpsTimestamp" type="int64">
+        <entry name="gpsTimestamp" type="int64" visibility="public">
           <description>Time GPS fix was made to include in
           EXIF</description>
           <units>UTC in seconds since January 1, 1970</units>
           <tag id="BC" />
         </entry>
-        <entry name="orientation" type="int32">
+        <entry name="orientation" type="int32" visibility="public">
           <description>Orientation of JPEG image to
           write</description>
           <units>Degrees in multiples of 90</units>
           <range>0, 90, 180, 270</range>
           <tag id="BC" />
         </entry>
-        <entry name="quality" type="byte">
+        <entry name="quality" type="byte" visibility="public">
           <description>Compression quality of the final JPEG
           image</description>
           <range>1-100; larger is higher quality</range>
           <notes>85-95 is typical usage range</notes>
           <tag id="BC" />
         </entry>
-        <entry name="thumbnailQuality" type="byte">
+        <entry name="thumbnailQuality" type="byte" visibility="public">
           <description>Compression quality of JPEG
           thumbnail</description>
           <range>1-100; larger is higher quality</range>
           <tag id="BC" />
         </entry>
-        <entry name="thumbnailSize" type="int32" container="array">
+        <entry name="thumbnailSize" type="int32" visibility="public"
+        container="array" typedef="size">
           <array>
             <size>2</size>
           </array>
@@ -1015,8 +1113,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </controls>
       <static>
-        <entry name="availableThumbnailSizes" type="int32"
-        type_notes="list of resolution pairs" container="array">
+        <entry name="availableThumbnailSizes" type="int32" visibility="public"
+        type_notes="list of resolution pairs" container="array" typedef="size">
           <array>
             <size>2</size>
             <size>n</size>
@@ -1027,7 +1125,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           (0,0) for no thumbnail generation</range>
           <tag id="BC" />
         </entry>
-        <entry name="maxSize" type="int32">
+        <entry name="maxSize" type="int32" visibility="system">
           <description>Maximum size in bytes for the compressed
           JPEG buffer</description>
           <range>Must be large enough to fit any JPEG produced by
@@ -1052,13 +1150,14 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           bytes</description>
           <range>&gt;= 0</range>
           <notes>If no JPEG output is produced for the request,
-          this must be 0. Otherwise, this describes the real size
-          of the compressed JPEG image placed in the output stream.
-          More specifically, if android.jpeg.maxSize = 1000000, and
-          a specific capture has android.jpeg.size = 500000, then
-          the output buffer from the JPEG stream will be 1000000
-          bytes, of which the first 500000 make up the real
-          data.</notes>
+          this must be 0.
+
+          Otherwise, this describes the real size of the compressed
+          JPEG image placed in the output stream.  More specifically,
+          if android.jpeg.maxSize = 1000000, and a specific capture
+          has android.jpeg.size = 500000, then the output buffer from
+          the JPEG stream will be 1000000 bytes, of which the first
+          500000 make up the real data.</notes>
         </entry>
         <clone entry="android.jpeg.thumbnailQuality"
         kind="controls"></clone>
@@ -1068,7 +1167,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="lens">
       <controls>
-        <entry name="aperture" type="float">
+        <entry name="aperture" type="float" visibility="public">
           <description>Size of the lens aperture</description>
           <units>f-number (f/NNN)</units>
           <range>android.lens.info.availableApertures</range>
@@ -1076,7 +1175,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           pick from supported list</notes>
           <tag id="V1" />
         </entry>
-        <entry name="filterDensity" type="float">
+        <entry name="filterDensity" type="float" visibility="public">
           <description>State of lens neutral density
           filter(s)</description>
           <units>number of stops of filtering</units>
@@ -1085,14 +1184,14 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           pick from supported list</notes>
           <tag id="V1" />
         </entry>
-        <entry name="focalLength" type="float">
+        <entry name="focalLength" type="float" visibility="public">
           <description>Lens optical zoom setting</description>
           <units>focal length in mm</units>
           <range>&gt; 0</range>
           <notes>Will not be supported on most devices.</notes>
           <tag id="V1" />
         </entry>
-        <entry name="focusDistance" type="float">
+        <entry name="focusDistance" type="float" visibility="public">
           <description>Distance to plane of sharpest focus,
           measured from frontmost surface of the lens</description>
           <units>diopters (1/m)</units>
@@ -1102,7 +1201,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <tag id="BC" />
           <tag id="V1" />
         </entry>
-        <entry name="opticalStabilizationMode" type="byte" enum="true">
+        <entry name="opticalStabilizationMode" type="byte" visibility="public"
+        enum="true">
           <enum>
             <value>OFF</value>
             <value optional="true">ON</value>
@@ -1116,7 +1216,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
       </controls>
       <static>
         <namespace name="info">
-          <entry name="availableApertures" type="float"
+          <entry name="availableApertures" type="float" visibility="public"
           container="array">
             <array>
               <size>n</size>
@@ -1128,7 +1228,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             should be for the fixed aperture</notes>
             <tag id="V1" />
           </entry>
-          <entry name="availableFilterDensities" type="float"
+          <entry name="availableFilterDensities" type="float" visibility="public"
           container="array">
             <array>
               <size>n</size>
@@ -1142,7 +1242,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             light by two stops)</notes>
             <tag id="V1" />
           </entry>
-          <entry name="availableFocalLengths" type="float"
+          <entry name="availableFocalLengths" type="float" visibility="public"
           type_notes="the list of available focal lengths"
           container="array">
             <array>
@@ -1158,7 +1258,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             <tag id="V1" />
           </entry>
           <entry name="availableOpticalStabilization" type="byte"
-          type_notes="list of enums" container="array">
+          visibility="public" type_notes="list of enums" container="array">
             <array>
               <size>n</size>
             </array>
@@ -1188,7 +1288,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           </entry>
           <entry name="geometricCorrectionMapSize" type="int32"
           type_notes="width and height of geometric correction map"
-          container="array">
+          container="array" typedef="size">
             <array>
               <size>2</size>
             </array>
@@ -1197,7 +1297,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             <range>Both values &gt;= 2</range>
             <tag id="V1" />
           </entry>
-          <entry name="hyperfocalDistance" type="float">
+          <entry name="hyperfocalDistance" type="float" visibility="public">
             <description>Hyperfocal distance for this lens; set to
             0 if fixed focus</description>
             <units>diopters</units>
@@ -1206,7 +1306,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             API's 'fixed' setting</notes>
             <tag id="BC" />
           </entry>
-          <entry name="minimumFocusDistance" type="float">
+          <entry name="minimumFocusDistance" type="float" visibility="public">
             <description>Shortest distance from frontmost surface
             of the lens that can be focused correctly</description>
             <units>diopters</units>
@@ -1215,26 +1315,9 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             0</notes>
             <tag id="V1" />
           </entry>
-          <entry name="shadingMap" type="float"
-          type_notes="2D array of float gain factors per channel to correct for lens falloff. Should be on the order of 3x40x30"
-          container="array">
-            <array>
-              <size>3</size>
-              <size>n</size>
-              <size>m</size>
-            </array>
-            <description>A low-resolution map of lens shading, per
-            color channel</description>
-            <range>Each gain factor is &gt;= 1</range>
-            <notes>Assume bilinear interpolation of map. The least
-            shaded section of the image should have a gain factor
-            of 1; all other sections should have gains above
-            1.</notes>
-            <tag id="DNG" />
-          </entry>
-          <entry name="shadingMapSize" type="int32"
-          type_notes="width and height of lens shading map"
-          container="array">
+          <entry name="shadingMapSize" type="int32" visibility="public"
+                 type_notes="width and height of lens shading map provided by the HAL. (N, M)"
+                 container="array" typedef="size">
             <array>
               <size>2</size>
             </array>
@@ -1244,7 +1327,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             <tag id="V1" />
           </entry>
         </namespace>
-        <entry name="facing" type="byte" enum="true">
+        <entry name="facing" type="byte" visibility="public" enum="true">
           <enum>
             <value>FRONT</value>
             <value>BACK</value>
@@ -1261,12 +1344,18 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>Relative angle of camera optical axis to the
           perpendicular axis from the display</description>
           <range>[0-90) for first angle, [0-360) for second</range>
-          <notes>Examples: (0,0) means that the camera optical axis
-          is perpendicular to the display surface; (45,0) means
-          that the camera points 45 degrees up when device is held
-          upright; (45,90) means the camera points 45 degrees to
-          the right when the device is held upright. Use FACING
-          field to determine perpendicular outgoing
+          <notes>Examples:
+
+          (0,0) means that the camera optical axis
+          is perpendicular to the display surface;
+
+          (45,0) means that the camera points 45 degrees up when
+          device is held upright;
+
+          (45,90) means the camera points 45 degrees to the right when
+          the device is held upright.
+
+          Use FACING field to determine perpendicular outgoing
           direction</notes>
           <tag id="ADV" />
         </entry>
@@ -1294,7 +1383,12 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>Should be zero for fixed-focus cameras</notes>
           <tag id="BC" />
         </clone>
-        <entry name="focusRange" type="float">
+        <entry name="focusRange" type="float" visibility="public"
+        type_notes="Range of scene distances that are in focus"
+        container="array">
+          <array>
+            <size>2</size>
+          </array>
           <description>The range of scene distances that are in
           sharp focus (depth of field)</description>
           <units>pair of focus distances in diopters: (near,
@@ -1308,9 +1402,10 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         kind="controls">
           <tag id="V1" />
         </clone>
-        <entry name="state" type="byte" enum="true">
+        <entry name="state" type="byte" visibility="public" enum="true">
           <enum>
             <value>STATIONARY</value>
+            <value>MOVING</value>
           </enum>
           <description>Current lens status</description>
           <tag id="V1" />
@@ -1319,7 +1414,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="noiseReduction">
       <controls>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF
             <notes>No noise reduction is applied</notes></value>
@@ -1349,20 +1444,21 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="quirks">
       <static>
-        <entry name="meteringCropRegion" type="byte">
+        <entry name="meteringCropRegion" type="byte" visibility="system">
           <description>If set to 1, the camera service does not
           scale 'normalized' coordinates with respect to the crop
           region. This applies to metering input (a{e,f,wb}Region
           and output (face rectangles).</description>
           <notes>Normalized coordinates refer to those in the
           (-1000,1000) range mentioned in the
-          android.hardware.Camera API. HAL implementations should
-          instead always use and emit sensor array-relative
-          coordinates for all region data. Does not need to be
-          listed in static metadata. Support will be removed in
-          future versions of camera service.</notes>
+          android.hardware.Camera API.
+
+          HAL implementations should instead always use and emit
+          sensor array-relative coordinates for all region data. Does
+          not need to be listed in static metadata. Support will be
+          removed in future versions of camera service.</notes>
         </entry>
-        <entry name="triggerAfWithAuto" type="byte">
+        <entry name="triggerAfWithAuto" type="byte" visibility="system">
           <description>If set to 1, then the camera service always
           switches to FOCUS_MODE_AUTO before issuing a AF
           trigger.</description>
@@ -1372,7 +1468,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           not need to be listed in static metadata. Support will be
           removed in future versions of camera service</notes>
         </entry>
-        <entry name="useZslFormat" type="byte">
+        <entry name="useZslFormat" type="byte" visibility="system">
           <description>If set to 1, the camera service uses
           CAMERA2_PIXEL_FORMAT_ZSL instead of
           HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED for the zero
@@ -1388,13 +1484,16 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="request">
       <controls>
-        <entry name="frameCount" type="int32">
+        <entry name="frameCount" type="int32" visibility="system">
           <description>A frame counter set by the framework. Must
-          be maintained unchanged in output frame</description>
+          be maintained unchanged in output frame. This value monotonically
+          increases with every new result (that is, each new result has a unique
+          frameCount value).
+          </description>
           <units>incrementing integer</units>
           <range>Any int</range>
         </entry>
-        <entry name="id" type="int32">
+        <entry name="id" type="int32" visibility="hidden">
           <description>An application-specified ID for the current
           request. Must be maintained unchanged in output
           frame</description>
@@ -1402,19 +1501,26 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>Any int</range>
           <tag id="V1" />
         </entry>
-        <entry name="inputStreams" type="byte">
+        <entry name="inputStreams" type="int32" visibility="system"
+               container="array">
+          <array>
+            <size>n</size>
+          </array>
           <description>List which camera reprocess stream is used
           for the source of reprocessing data.</description>
           <units>List of camera reprocess stream IDs</units>
           <range>Typically, only one entry allowed, must be a valid
-          reprocess stream ID. If android.jpeg.needsThumbnail is
-          set, then multiple reprocess streams may be included in a
-          single request; they must be different scaled versions of
-          the same image.</range>
+          reprocess stream ID.
+
+          If android.jpeg.needsThumbnail is set, then multiple
+          reprocess streams may be included in a single request; they
+          must be different scaled versions of the same image.</range>
           <notes>Only meaningful when android.request.type ==
           REPROCESS. Ignored otherwise</notes>
+          <tag id="HAL2" />
         </entry>
-        <entry name="metadataMode" type="byte" enum="true">
+        <entry name="metadataMode" type="byte" visibility="system"
+               enum="true">
           <enum>
             <value>NONE
             <notes>No metadata should be produced on output, except
@@ -1433,7 +1539,11 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>How much metadata to produce on
           output</description>
         </entry>
-        <entry name="outputStreams" type="byte">
+        <entry name="outputStreams" type="int32" visibility="system"
+               container="array">
+          <array>
+            <size>n</size>
+          </array>
           <description>Lists which camera output streams image data
           from this capture must be sent to</description>
           <units>List of camera stream IDs</units>
@@ -1443,8 +1553,9 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           data should simply be discarded. The image data must
           still be captured for metadata and statistics production,
           and the lens and flash must operate as requested.</notes>
+          <tag id="HAL2" />
         </entry>
-        <entry name="type" type="byte" enum="true">
+        <entry name="type" type="byte" visibility="system" enum="true">
           <enum>
             <value>CAPTURE
             <notes>Capture a new image from the imaging hardware,
@@ -1457,11 +1568,12 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             needed for reprocessing with [RP]</notes></value>
           </enum>
           <description>The type of the request; either CAPTURE or
-          REPROCESS</description>
+          REPROCESS. For HAL3, this tag is redundant.</description>
+          <tag id="HAL2" />
         </entry>
       </controls>
       <static>
-        <entry name="maxNumOutputStreams" type="int32"
+        <entry name="maxNumOutputStreams" type="int32" visibility="public"
         container="array">
           <array>
             <size>3</size>
@@ -1478,7 +1590,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           one JPEG stream (snapshot)</notes>
           <tag id="BC" />
         </entry>
-        <entry name="maxNumReprocessStreams" type="int32"
+        <entry name="maxNumReprocessStreams" type="int32" visibility="system"
         container="array">
           <array>
             <size>1</size>
@@ -1489,9 +1601,10 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </static>
       <dynamic>
-        <entry name="frameCount" type="int32">
-          <description>Number of frames captured since
-          open()</description>
+        <entry name="frameCount" type="int32" visibility="public">
+          <description>A frame counter set by the framework. This value monotonically
+          increases with every new result (that is, each new result has a unique
+          frameCount value).</description>
           <units>count of frames</units>
           <range>&gt; 0</range>
           <notes>Reset on release()</notes>
@@ -1505,7 +1618,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="scaler">
       <controls>
-        <entry name="cropRegion" type="int32" container="array">
+        <entry name="cropRegion" type="int32" visibility="public"
+               container="array" typedef="rectangle">
           <array>
             <size>4</size>
           </array>
@@ -1552,9 +1666,10 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </controls>
       <static>
-        <entry name="availableFormats" type="int32" enum="true"
+        <entry name="availableFormats" type="int32"
+        visibility="public" enum="true"
         type_notes="values from HAL_PIXEL_FORMAT_* in /system/core/include/system/graphics.h"
-        container="array">
+        container="array" typedef="imageFormat">
           <array>
             <size>n</size>
           </array>
@@ -1583,7 +1698,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>List of app-visible formats</description>
           <tag id="BC" />
         </entry>
-        <entry name="availableJpegMinDurations" type="int64"
+        <entry name="availableJpegMinDurations" type="int64" visibility="public"
         container="array">
           <array>
             <size>n</size>
@@ -1591,15 +1706,15 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>The minimum frame duration that is supported
           for each resolution in availableJpegSizes. Should
           correspond to the frame duration when only that JPEG
-          stream is active, with all processing set to
-          FAST</description>
+          stream is active and captured in a burst, with all
+          processing set to FAST</description>
           <notes>When multiple streams are configured, the minimum
           frame duration will be &gt;= max(individual stream min
           durations)</notes>
           <tag id="BC" />
         </entry>
-        <entry name="availableJpegSizes" type="int32"
-        container="array">
+        <entry name="availableJpegSizes" type="int32" visibility="public"
+        container="array" typedef="size">
           <array>
             <size>n</size>
             <size>2</size>
@@ -1610,7 +1725,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           include: - half/quarter max resolution</range>
           <tag id="BC" />
         </entry>
-        <entry name="availableMaxDigitalZoom" type="float">
+        <entry name="availableMaxDigitalZoom" type="float" visibility="public">
           <description>The maximum ratio between active area width
           and crop region width, or between active area height and
           crop region height, if the crop region height is larger
@@ -1618,7 +1733,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>&gt;=1</range>
           <tag id="BC" />
         </entry>
-        <entry name="availableProcessedMinDurations" type="int64"
+        <entry name="availableProcessedMinDurations" type="int64" visibility="public"
         container="array">
           <array>
             <size>n</size>
@@ -1633,8 +1748,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           durations)</notes>
           <tag id="BC" />
         </entry>
-        <entry name="availableProcessedSizes" type="int32"
-        container="array">
+        <entry name="availableProcessedSizes" type="int32" visibility="public"
+        container="array" typedef="size">
           <array>
             <size>n</size>
             <size>2</size>
@@ -1646,6 +1761,13 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <range>Must include: - sensor maximum resolution -
           standard QCIF, 240p, 480p, 720p, and 1080p
           resolutions</range>
+          <notes>The actual supported resolution list may be limited by
+          consumer end points for different use cases. For example, for
+          recording use case, the largest supported resolution may be
+          limited by max supported size from encoder, for preview use
+          case, the largest supported resolution may be limited by max
+          resolution SurfaceTexture/SurfaceView can support.
+          </notes>
           <tag id="BC" />
         </entry>
         <entry name="availableRawMinDurations" type="int64"
@@ -1663,7 +1785,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <tag id="BC" />
         </entry>
         <entry name="availableRawSizes" type="int32"
-        container="array">
+        container="array" typedef="size">
           <array>
             <size>n</size>
             <size>2</size>
@@ -1681,15 +1803,19 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="sensor">
       <controls>
-        <entry name="exposureTime" type="int64">
+        <entry name="exposureTime" type="int64" visibility="public">
           <description>Duration each pixel is exposed to
-          light</description>
+          light.
+
+          If the sensor can't expose this exact duration, it should shorten the
+          duration exposed to the nearest possible value (rather than expose longer).
+          </description>
           <units>nanoseconds</units>
           <range>android.sensor.info.exposureTimeRange</range>
           <notes>1/10000 - 30 sec range. No bulb mode</notes>
           <tag id="V1" />
         </entry>
-        <entry name="frameDuration" type="int64">
+        <entry name="frameDuration" type="int64" visibility="public">
           <description>Duration from start of frame exposure to
           start of next frame exposure</description>
           <units>nanoseconds</units>
@@ -1700,10 +1826,14 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <tag id="V1" />
           <tag id="BC" />
         </entry>
-        <entry name="sensitivity" type="int32">
+        <entry name="sensitivity" type="int32" visibility="public">
           <description>Gain applied to image data. Must be
           implemented through analog gain only if set to values
-          below 'maximum analog sensitivity'.</description>
+          below 'maximum analog sensitivity'.
+
+          If the sensor can't apply this exact gain, it should lessen the
+          gain to the nearest possible value (rather than gain more).
+          </description>
           <units>ISO arithmetic units</units>
           <range>android.sensor.info.sensitivityRange</range>
           <notes>ISO 12232:2006 REI method</notes>
@@ -1712,9 +1842,10 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
       </controls>
       <static>
         <namespace name="info">
-          <entry name="activeArraySize" type="int32"
+          <entry name="activeArraySize" type="int32" visibility="public"
           type_notes="Four ints defining the active pixel rectangle"
-          container="array">
+          container="array"
+          typedef="rectangle">
             <array>
               <size>4</size>
             </array>
@@ -1725,15 +1856,14 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             pixel array is (0,0)</units>
             <tag id="DNG" />
           </entry>
-          <entry name="availableSensitivities" type="int32"
-          type_notes="List of supported sensitivity values"
+          <entry name="sensitivityRange" type="int32" visibility="public"
+          type_notes="Range of supported sensitivities"
           container="array">
             <array>
-              <size>n</size>
+              <size>2</size>
             </array>
             <description>Range of valid sensitivities</description>
-            <range>Must at least include 100, 200, 400, 800,
-            1600</range>
+            <range>Min &lt;= 100, Max &gt;= 1600</range>
             <tag id="BC" />
             <tag id="V1" />
           </entry>
@@ -1753,7 +1883,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             the sensor, in reading order</description>
             <tag id="DNG" />
           </entry>
-          <entry name="exposureTimeRange" type="int64"
+          <entry name="exposureTimeRange" type="int64" visibility="public"
           type_notes="nanoseconds" container="array">
             <array>
               <size>2</size>
@@ -1764,18 +1894,20 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             sec)</range>
             <tag id="V1" />
           </entry>
-          <entry name="maxFrameDuration" type="int64">
-            <description>Maximum frame duration (minimum frame
+          <entry name="maxFrameDuration" type="int64" visibility="public">
+            <description>Maximum possible frame duration (minimum frame
             rate)</description>
             <units>nanoseconds</units>
             <range>&gt;= 30e9</range>
             <notes>Minimum duration is a function of resolution,
             processing settings. See
-            android.scaler.info.availableMinFrameDurations</notes>
+            android.scaler.availableProcessedMinDurations
+            android.scaler.availableJpegMinDurations
+            android.scaler.availableRawMinDurations</notes>
             <tag id="BC" />
             <tag id="V1" />
           </entry>
-          <entry name="physicalSize" type="float"
+          <entry name="physicalSize" type="float" visibility="public"
           type_notes="width x height in millimeters"
           container="array">
             <array>
@@ -1788,7 +1920,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             <tag id="BC" />
           </entry>
           <entry name="pixelArraySize" type="int32"
-          container="array">
+          container="array" typedef="size">
             <array>
               <size>2</size>
             </array>
@@ -1809,10 +1941,12 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             <tag id="DNG" />
           </entry>
         </namespace>
-        <entry name="baseGainFactor" type="rational">
+        <entry name="baseGainFactor" type="rational" visibility="public"
+        optional="true">
           <description>Gain factor from electrons to raw units when
           ISO=100</description>
           <tag id="V1" />
+          <tag id="FULL" />
         </entry>
         <entry name="blackLevelPattern" type="int32"
         type_notes="2x2 raw count block" container="array">
@@ -1891,7 +2025,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           adaptation</description>
           <tag id="DNG" />
         </entry>
-        <entry name="maxAnalogSensitivity" type="int32">
+        <entry name="maxAnalogSensitivity" type="int32" visibility="public"
+        optional="true">
           <description>Maximum sensitivity that is implemented
           purely through analog gain</description>
           <notes>For android.sensor.sensitivity values less than or
@@ -1899,6 +2034,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           values above this, it can be a mix of analog and
           digital</notes>
           <tag id="V1" />
+          <tag id="FULL" />
         </entry>
         <entry name="noiseModelCoefficients" type="float"
         type_notes="float constants A, B for the noise variance model"
@@ -1918,7 +2054,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           across the sensor</notes>
           <tag id="V1" />
         </entry>
-        <entry name="orientation" type="int32">
+        <entry name="orientation" type="int32" visibility="public">
           <description>Clockwise angle through which the output
           image needs to be rotated to be upright on the device
           screen in its native orientation. Also defines the
@@ -1976,7 +2112,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         kind="controls"></clone>
         <clone entry="android.sensor.sensitivity" kind="controls">
         </clone>
-        <entry name="timestamp" type="int64">
+        <entry name="timestamp" type="int64" visibility="public">
           <description>Time at start of exposure of first
           row</description>
           <units>nanoseconds</units>
@@ -1985,6 +2121,19 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           system</notes>
           <tag id="BC" />
         </entry>
+        <entry name="temperature" type="float" visibility="public"
+        optional="true">
+          <description>The temperature of the sensor, sampled at the time
+          exposure began for this frame.
+
+          The thermal diode being queried should be inside the sensor PCB, or
+          somewhere close to it.
+          </description>
+
+          <units>celsius</units>
+          <range>Optional. This value is missing if no temperature is available.</range>
+          <tag id="FULL" />
+        </entry>
       </dynamic>
     </section>
     <section name="shading">
@@ -2018,7 +2167,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="statistics">
       <controls>
-        <entry name="faceDetectMode" type="byte" enum="true">
+        <entry name="faceDetectMode" type="byte" visibility="public" enum="true">
           <enum>
             <value>OFF</value>
             <value>SIMPLE
@@ -2031,10 +2180,14 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <description>State of the face detector
           unit</description>
           <range>
-          android.statistics.availableFaceDetectModes</range>
+          android.statistics.info.availableFaceDetectModes</range>
+          <notes>Whether face detection is enabled, and whether it
+          should output just the basic fields or the full set of
+          fields. Value must be one of the
+          android.statistics.info.availableFaceDetectModes.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="histogramMode" type="byte" enum="true">
+        <entry name="histogramMode" type="byte" enum="true" typedef="boolean">
           <enum>
             <value>OFF</value>
             <value>ON</value>
@@ -2043,7 +2196,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           generation</description>
           <tag id="V1" />
         </entry>
-        <entry name="sharpnessMapMode" type="byte" enum="true">
+        <entry name="sharpnessMapMode" type="byte" enum="true" typedef="boolean">
           <enum>
             <value>OFF</value>
             <value>ON</value>
@@ -2056,22 +2209,38 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
       <static>
         <namespace name="info">
           <entry name="availableFaceDetectModes" type="byte"
-          type_notes="List of enums" container="array">
+                 visibility="public"
+                 type_notes="List of enums from android.statistics.faceDetectMode"
+                 container="array">
             <array>
               <size>n</size>
             </array>
             <description>Which face detection modes are available,
             if any</description>
-            <range>OFF</range>
+            <units>List of enum:
+            OFF
+            SIMPLE
+            FULL</units>
+            <notes>OFF means face detection is disabled, it must
+            be included in the list.
+
+            SIMPLE means the device supports the
+            android.statistics.faceRectangles and
+            android.statistics.faceScores outputs.
+
+            FULL means the device additionally supports the
+            android.statistics.faceIds and
+            android.statistics.faceLandmarks outputs.
+            </notes>
           </entry>
           <entry name="histogramBucketCount" type="int32">
             <description>Number of histogram buckets
             supported</description>
             <range>&gt;= 64</range>
           </entry>
-          <entry name="maxFaceCount" type="int32">
-            <description>If face detection is supported, how many
-            faces can be detected at once</description>
+          <entry name="maxFaceCount" type="int32" visibility="public" >
+            <description>Maximum number of simultaneously detectable
+            faces</description>
             <range>&gt;= 4 if availableFaceDetectionModes lists
             modes besides OFF, otherwise 0</range>
           </entry>
@@ -2084,7 +2253,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
             region.</description>
           </entry>
           <entry name="sharpnessMapSize" type="int32"
-          type_notes="width x height" container="array">
+          type_notes="width x height" container="array" typedef="size">
             <array>
               <size>2</size>
             </array>
@@ -2097,7 +2266,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
       <dynamic>
         <clone entry="android.statistics.faceDetectMode"
         kind="controls"></clone>
-        <entry name="faceIds" type="int32" container="array">
+        <entry name="faceIds" type="int32" visibility="public" container="array">
           <array>
             <size>n</size>
           </array>
@@ -2106,7 +2275,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>Only available if faceDetectMode == FULL</notes>
           <tag id="BC" />
         </entry>
-        <entry name="faceLandmarks" type="int32"
+        <entry name="faceLandmarks" type="int32" visibility="public"
         type_notes="(leftEyeX, leftEyeY, rightEyeX, rightEyeY, mouthX, mouthY)"
         container="array">
           <array>
@@ -2118,9 +2287,9 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>Only available if faceDetectMode == FULL</notes>
           <tag id="BC" />
         </entry>
-        <entry name="faceRectangles" type="int32"
+        <entry name="faceRectangles" type="int32" visibility="public"
         type_notes="(xmin, ymin, xmax, ymax). (0,0) is top-left of active pixel area"
-        container="array">
+        container="array" typedef="rectangle">
           <array>
             <size>n</size>
             <size>4</size>
@@ -2130,14 +2299,15 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           <notes>Only available if faceDetectMode != OFF</notes>
           <tag id="BC" />
         </entry>
-        <entry name="faceScores" type="byte" container="array">
+        <entry name="faceScores" type="byte" visibility="public" container="array">
           <array>
             <size>n</size>
           </array>
           <description>List of the face confidence scores for
           detected faces</description>
-          <range>0-100</range>
-          <notes>Only available if faceDetectMode != OFF</notes>
+          <range>1-100</range>
+          <notes>Only available if faceDetectMode != OFF. The value should be
+          meaningful (for example, setting 100 at all times is illegal).</notes>
           <tag id="BC" />
         </entry>
         <entry name="histogram" type="int32"
@@ -2173,24 +2343,137 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
         <clone entry="android.statistics.sharpnessMapMode"
         kind="controls"></clone>
+        <entry name="lensShadingMap" type="float" visibility="public"
+               type_notes="2D array of float gain factors per channel to correct lens shading"
+               container="array">
+          <array>
+            <size>4</size>
+            <size>n</size>
+            <size>m</size>
+          </array>
+          <description>A low-resolution map of lens shading, per
+          color channel</description>
+          <range>Each gain factor is &gt;= 1</range>
+          <notes>Assume bilinear interpolation of map. The least
+          shaded section of the image should have a gain factor
+          of 1; all other sections should have gains above 1.
+          the map should be on the order of 30-40 rows, and
+          must be smaller than 64x64.
+
+          When android.colorCorrection.mode = TRANSFORM_MATRIX, the map
+          must take into account the colorCorrection settings.
+          </notes>
+        </entry>
+        <entry name="predictedColorGains" type="float" visibility="public"
+               type_notes="A 1D array of floats for 4 color channel gains"
+               container="array">
+          <array>
+            <size>4</size>
+          </array>
+          <description>The best-fit color channel gains calculated
+          by the HAL's statistics units for the current output frame
+          </description>
+          <notes>
+          This may be different than the gains used for this frame,
+          since statistics processing on data from a new frame
+          typically completes after the transform has already been
+          applied to that frame.
+
+          The 4 channel gains are defined in Bayer domain,
+          see android.colorCorrection.gains for details.
+
+          This value should always be calculated by the AWB block,
+          regardless of the android.control.* current values.
+          </notes>
+        </entry>
+        <entry name="predictedColorTransform" type="rational" visibility="public"
+               type_notes="3x3 rational matrix in row-major order"
+               container="array">
+          <array>
+            <size>3</size>
+            <size>3</size>
+          </array>
+          <description>The best-fit color transform matrix estimate
+          calculated by the HAL's statistics units for the current
+          output frame</description>
+          <notes>The HAL must provide the estimate from its
+          statistics unit on the white balance transforms to use
+          for the next frame. These are the values the HAL believes
+          are the best fit for the current output frame. This may
+          be different than the transform used for this frame, since
+          statistics processing on data from a new frame typically
+          completes after the transform has already been applied to
+          that frame.
+
+          These estimates must be provided for all frames, even if
+          capture settings and color transforms are set by the application.
+
+          This value should always be calculated by the AWB block,
+          regardless of the android.control.* current values.
+          </notes>
+        </entry>
+        <entry name="sceneFlicker" type="byte" visibility="public" enum="true">
+          <enum>
+            <value>NONE</value>
+            <value>50HZ</value>
+            <value>60HZ</value>
+          </enum>
+          <description>The HAL estimated scene illumination lighting
+          frequency</description>
+          <notes>Report NONE if there doesn't appear to be flickering
+          illumination</notes>
+        </entry>
       </dynamic>
+      <controls>
+        <entry name="lensShadingMapMode" type="byte" visibility="public" enum="true">
+          <enum>
+            <value>OFF</value>
+            <value>ON</value>
+          </enum>
+          <description>Whether the HAL needs to output the lens
+          shading map in output result metadata</description>
+          <notes>When set to ON,
+          android.statistics.lensShadingMap must be provided in
+          the output result metdata.</notes>
+        </entry>
+      </controls>
     </section>
     <section name="tonemap">
       <controls>
-        <entry name="curveBlue" type="float">
+        <entry name="curveBlue" type="float" visibility="public"
+        type_notes="1D array of float pairs (P_IN, P_OUT). The maximum number of pairs is specified by android.tonemap.maxCurvePoints."
+        container="array">
+          <array>
+            <size>n</size>
+            <size>2</size>
+          </array>
           <description>Table mapping blue input values to output
           values</description>
           <units>same as android.tonemap.curveRed</units>
           <range>same as android.tonemap.curveRed</range>
+          <notes>Tonemapping / contrast / gamma curve for the blue
+          channel, to use when android.tonemap.mode is CONTRAST_CURVE.
+
+          See android.tonemap.curveRed for more details.</notes>
         </entry>
-        <entry name="curveGreen" type="float">
+        <entry name="curveGreen" type="float" visibility="public"
+        type_notes="1D array of float pairs (P_IN, P_OUT). The maximum number of pairs is specified by android.tonemap.maxCurvePoints."
+        container="array">
+          <array>
+            <size>n</size>
+            <size>2</size>
+          </array>
           <description>Table mapping green input values to output
           values</description>
           <units>same as android.tonemap.curveRed</units>
           <range>same as android.tonemap.curveRed</range>
+          <notes>Tonemapping / contrast / gamma curve for the green
+          channel, to use when android.tonemap.mode is CONTRAST_CURVE.
+
+          See android.tonemap.curveRed for more details.</notes>
         </entry>
-        <entry name="curveRed" type="float"
-        type_notes="A 1D array of pairs of floats. mapping a 0-1 input range to a 0-1 output range."
+        <entry name="curveRed" type="float" visibility="public"
+        type_notes="1D array of float pairs (P_IN, P_OUT). The maximum number of pairs is specified by android.tonemap.maxCurvePoints."
         container="array">
           <array>
             <size>n</size>
@@ -2198,17 +2481,24 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
           </array>
           <description>Table mapping red input values to output
           values</description>
-          <range>0-1 on input and output coordinates. Max entry
-          count speciied by android.tonemap.maxCurvePoints</range>
-          <notes>.The input range must be monotonically increasing
-          with N, and values between entries should be linearly
-          interpolated. For example, if the array is: [0.0, 0.0,
+          <range>0-1 on input and output coordinates.</range>
+          <notes>Tonemapping / contrast / gamma curve for the red
+          channel, to use when android.tonemap.mode is CONTRAST_CURVE.
+
+          Since the input and output ranges may vary depending on
+          the camera pipeline, the input and output pixel values
+          are represented by normalized floating-point values
+          between 0 and 1, with 0 == black and 1 == white.
+
+          The curve should be linearly interpolated between the
+          defined points. The points will be listed in increasing
+          order of P_IN. For example, if the array is: [0.0, 0.0,
           0.3, 0.5, 1.0, 1.0], then the input-&gt;output mapping
           for a few sample points would be: 0 -&gt; 0, 0.15 -&gt;
           0.25, 0.3 -&gt; 0.5, 0.5 -&gt; 0.64</notes>
           <tag id="DNG" />
         </entry>
-        <entry name="mode" type="byte" enum="true">
+        <entry name="mode" type="byte" visibility="public" enum="true">
           <enum>
             <value>CONTRAST_CURVE
             <notes>Use the tone mapping curve specified in
@@ -2223,7 +2513,7 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </controls>
       <static>
-        <entry name="maxCurvePoints" type="int32">
+        <entry name="maxCurvePoints" type="int32" visibility="public" >
           <description>Maximum number of supported points in the
           tonemap curve</description>
           <range>&gt;= 128</range>
@@ -2242,7 +2532,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="led">
       <controls>
-        <entry name="transmit" type="byte" enum="true">
+        <entry name="transmit" type="byte" visibility="hidden" enum="true"
+               typedef="boolean">
           <enum>
             <value>OFF</value>
             <value>ON</value>
@@ -2266,7 +2557,8 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         <clone entry="android.led.transmit" kind="controls"></clone>
       </dynamic>
       <static>
-        <entry name="availableLeds" type="byte" enum="true" container="array">
+        <entry name="availableLeds" type="byte" visibility="hidden" enum="true"
+               container="array">
           <array>
             <size>n</size>
           </array>
@@ -2282,18 +2574,20 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
     </section>
     <section name="info">
       <static>
-        <entry name="supportedHardwareLevel" type="byte" enum="true">
+        <entry name="supportedHardwareLevel" type="byte" visibility="public"
+               enum="true" >
           <enum>
             <value>LIMITED</value>
             <value>FULL</value>
           </enum>
           <description>
-          The camera 3 HAL device can implement one of two possible operational modes;
-          limited and full. Full support is expected from new higher-end
-          devices. Limited mode has hardware requirements roughly in line with those
-          for a camera HAL device v1 implementation, and is expected from older or
-          inexpensive devices. Full is a strict superset of limited, and they share the
-          same essential operational flow.
+          The camera 3 HAL device can implement one of two possible
+          operational modes; limited and full. Full support is
+          expected from new higher-end devices. Limited mode has
+          hardware requirements roughly in line with those for a
+          camera HAL device v1 implementation, and is expected from
+          older or inexpensive devices. Full is a strict superset of
+          limited, and they share the same essential operational flow.
 
           For full details refer to "S3. Operational Modes" in camera3.h
           </description>
@@ -2301,5 +2595,39 @@ xsi:schemaLocation="http://schemas.android.com/service/camera/metadata/ metadata
         </entry>
       </static>
     </section>
+    <section name="blackLevel">
+      <controls>
+        <entry name="lock" type="byte" visibility="public" enum="true"
+               typedef="boolean">
+          <enum>
+            <value>OFF</value>
+            <value>ON</value>
+          </enum>
+          <description> Whether black-level compensation is locked
+          to its current values, or is free to vary</description>
+          <notes>When set to ON, the values used for black-level
+          compensation must not change until the lock is set to
+          OFF
+
+          Since changes to certain capture parameters (such as
+          exposure time) may require resetting of black level
+          compensation, the HAL must report whether setting the
+          black level lock was successful in the output result
+          metadata.
+
+          The black level locking must happen at the sensor, and not at the ISP.
+          If for some reason black level locking is no longer legal (for example,
+          the analog gain has changed, which forces black levels to be
+          recalculated), then the HAL is free to override this request (and it
+          must report 'OFF' when this does happen) until the next time locking
+          is legal again.</notes>
+          <tag id="HAL2" />
+        </entry>
+      </controls>
+      <dynamic>
+        <clone entry="android.blackLevel.lock"
+        kind="controls"></clone>
+      </dynamic>
+    </section>
   </namespace>
 </metadata>
diff --git a/camera/docs/metadata_properties.xsd b/camera/docs/metadata_properties.xsd
index 259aebfe..851dfd6a 100644
--- a/camera/docs/metadata_properties.xsd
+++ b/camera/docs/metadata_properties.xsd
@@ -18,11 +18,23 @@
     targetNamespace="http://schemas.android.com/service/camera/metadata/"
     elementFormDefault="qualified">
 
-    <element name="metadata" type="tns:MetadataType"></element>
+    <element name="metadata" type="tns:MetadataType">
+        <key name="TypeNameKey">
+            <selector xpath="tns:types/tns:typedef" />
+            <field xpath="@name" />
+        </key>
+
+        <!-- ensure that <entry typedef="..."> refers to a valid <typedef name='..."/> -->
+        <keyref name="TypeNameKeyRef" refer="tns:TypeNameKey">
+            <selector xpath=".//tns:entry" /> <!-- recursively find any descendant entry -->
+            <field xpath="@typedef" />
+        </keyref>
+    </element>
 
     <complexType name="MetadataType">
         <sequence>
             <element name="tags" type="tns:TagsType" maxOccurs="1" minOccurs="0"></element>
+            <element name="types" type="tns:TypesType" maxOccurs="1" minOccurs="0"></element>
             <element name="namespace" type="tns:NamespaceType"
                 maxOccurs="unbounded" minOccurs="1">
             </element>
@@ -86,6 +98,36 @@
         </simpleContent>
     </complexType>
 
+    <complexType name="TypesType">
+        <sequence>
+            <element name="typedef" type="tns:TypedefType" maxOccurs="unbounded" minOccurs="0">
+            </element>
+        </sequence>
+    </complexType>
+
+    <complexType name="TypedefType">
+        <sequence>
+            <element name="language" type="tns:LanguageType" maxOccurs="unbounded" minOccurs="1"></element>
+        </sequence>
+        <attribute name="name" type="string" use="required" />
+    </complexType>
+
+    <complexType name="LanguageType">
+        <simpleContent>
+            <extension base="string">
+                <attribute name="name" use="required">
+                    <simpleType>
+                        <restriction base="string">
+                            <enumeration value="java" />
+                            <enumeration value="c" />
+                            <enumeration value="c++" />
+                        </restriction>
+                    </simpleType>
+                </attribute>
+            </extension>
+        </simpleContent>
+    </complexType>
+
     <group name="BaseEntryGroup">
         <sequence>
             <element name="description" type="string" maxOccurs="1"
@@ -146,6 +188,24 @@
                 </restriction>
             </simpleType>
         </attribute>
+        <attribute name="visibility">
+            <simpleType>
+                <restriction base="string">
+                    <enumeration value="system" />
+                    <enumeration value="hidden" />
+                    <enumeration value="public" />
+                </restriction>
+            </simpleType>
+        </attribute>
+        <attribute name="optional" default="false">
+            <simpleType>
+                <restriction base="string">
+                    <enumeration value="false" />
+                    <enumeration value="true" />
+                </restriction>
+            </simpleType>
+        </attribute>
+        <attribute name="typedef" type="string" />
     </complexType>
 
     <complexType name="EnumType">
diff --git a/camera/docs/metadata_template.mako b/camera/docs/metadata_template.mako
index 253db61a..da151030 100644
--- a/camera/docs/metadata_template.mako
+++ b/camera/docs/metadata_template.mako
@@ -29,6 +29,16 @@
 % endfor
 </tags>
 
+<types>
+% for typedef in metadata.types:
+  <typedef name="${typedef.name}">
+    % for (language, klass) in typedef.languages.iteritems():
+      <language name="${language}">${klass}</language>
+    % endfor
+  </typedef>
+% endfor
+</types>
+
 % for root in metadata.outer_namespaces:
 <namespace name="${root.name}">
   % for section in root.sections:
@@ -72,6 +82,12 @@
             </clone>
         % else:
             <entry name="${prop.name_short}" type="${prop.type}"
+          % if prop.visibility:
+                visibility="${prop.visibility}"
+          % endif
+          % if prop.optional:
+                optional="${str(prop.optional).lower()}"
+          % endif
           % if prop.enum:
                 enum="true"
           % endif
@@ -81,6 +97,10 @@
           % if prop.container is not None:
                 container="${prop.container}"
           % endif
+
+          % if prop.typedef is not None:
+                typedef="${prop.typedef.name}"
+          % endif
             >
 
               % if prop.container == 'array':
diff --git a/camera/include/system/camera_metadata.h b/camera/include/system/camera_metadata.h
index a0e5cd13..f244ee11 100644
--- a/camera/include/system/camera_metadata.h
+++ b/camera/include/system/camera_metadata.h
@@ -465,6 +465,21 @@ struct vendor_tag_query_ops {
     int (*get_camera_vendor_tag_type)(
         const vendor_tag_query_ops_t *v,
         uint32_t tag);
+    /**
+     * Get the number of vendor tags supported on this platform. Used to
+     * calculate the size of buffer needed for holding the array of all tags
+     * returned by get_camera_vendor_tags().
+     */
+    int (*get_camera_vendor_tag_count)(
+        const vendor_tag_query_ops_t *v);
+    /**
+     * Fill an array with all the supported vendor tags on this platform.
+     * get_camera_vendor_tag_count() returns the number of tags supported, and
+     * tag_array should be allocated with enough space to hold all of the tags.
+     */
+    void (*get_camera_vendor_tags)(
+        const vendor_tag_query_ops_t *v,
+        uint32_t *tag_array);
 };
 
 ANDROID_API
diff --git a/camera/include/system/camera_metadata_tags.h b/camera/include/system/camera_metadata_tags.h
index 646c7ec9..70e88940 100644
--- a/camera/include/system/camera_metadata_tags.h
+++ b/camera/include/system/camera_metadata_tags.h
@@ -59,6 +59,7 @@ typedef enum camera_metadata_section {
     ANDROID_TONEMAP,
     ANDROID_LED,
     ANDROID_INFO,
+    ANDROID_BLACK_LEVEL,
     ANDROID_SECTION_COUNT,
 
     VENDOR_SECTION = 0x8000
@@ -93,6 +94,7 @@ typedef enum camera_metadata_section_start {
     ANDROID_TONEMAP_START          = ANDROID_TONEMAP           << 16,
     ANDROID_LED_START              = ANDROID_LED               << 16,
     ANDROID_INFO_START             = ANDROID_INFO              << 16,
+    ANDROID_BLACK_LEVEL_START      = ANDROID_BLACK_LEVEL       << 16,
     VENDOR_SECTION_START           = VENDOR_SECTION            << 16
 } camera_metadata_section_start_t;
 
@@ -103,215 +105,244 @@ typedef enum camera_metadata_section_start {
  * system/media/camera/src/camera_metadata_tag_info.c
  */
 typedef enum camera_metadata_tag {
-    ANDROID_COLOR_CORRECTION_MODE  = ANDROID_COLOR_CORRECTION_START,
-    ANDROID_COLOR_CORRECTION_TRANSFORM,
+    ANDROID_COLOR_CORRECTION_MODE =                   // enum         | public
+            ANDROID_COLOR_CORRECTION_START,
+    ANDROID_COLOR_CORRECTION_TRANSFORM,               // rational[]   | public
+    ANDROID_COLOR_CORRECTION_GAINS,                   // float[]      | public
     ANDROID_COLOR_CORRECTION_END,
 
-    ANDROID_CONTROL_AE_ANTIBANDING_MODE
-                                   = ANDROID_CONTROL_START,
-    ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
-    ANDROID_CONTROL_AE_LOCK,
-    ANDROID_CONTROL_AE_MODE,
-    ANDROID_CONTROL_AE_REGIONS,
-    ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-    ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
-    ANDROID_CONTROL_AF_MODE,
-    ANDROID_CONTROL_AF_REGIONS,
-    ANDROID_CONTROL_AF_TRIGGER,
-    ANDROID_CONTROL_AWB_LOCK,
-    ANDROID_CONTROL_AWB_MODE,
-    ANDROID_CONTROL_AWB_REGIONS,
-    ANDROID_CONTROL_CAPTURE_INTENT,
-    ANDROID_CONTROL_EFFECT_MODE,
-    ANDROID_CONTROL_MODE,
-    ANDROID_CONTROL_SCENE_MODE,
-    ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
-    ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-    ANDROID_CONTROL_AE_AVAILABLE_MODES,
-    ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-    ANDROID_CONTROL_AE_COMPENSATION_RANGE,
-    ANDROID_CONTROL_AE_COMPENSATION_STEP,
-    ANDROID_CONTROL_AF_AVAILABLE_MODES,
-    ANDROID_CONTROL_AVAILABLE_EFFECTS,
-    ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
+    ANDROID_CONTROL_AE_ANTIBANDING_MODE =             // enum         | public
+            ANDROID_CONTROL_START,
+    ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,         // int32        | public
+    ANDROID_CONTROL_AE_LOCK,                          // enum         | public
+    ANDROID_CONTROL_AE_MODE,                          // enum         | public
+    ANDROID_CONTROL_AE_REGIONS,                       // int32[]      | public
+    ANDROID_CONTROL_AE_TARGET_FPS_RANGE,              // int32[]      | public
+    ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,            // enum         | public
+    ANDROID_CONTROL_AF_MODE,                          // enum         | public
+    ANDROID_CONTROL_AF_REGIONS,                       // int32[]      | public
+    ANDROID_CONTROL_AF_TRIGGER,                       // enum         | public
+    ANDROID_CONTROL_AWB_LOCK,                         // enum         | public
+    ANDROID_CONTROL_AWB_MODE,                         // enum         | public
+    ANDROID_CONTROL_AWB_REGIONS,                      // int32[]      | public
+    ANDROID_CONTROL_CAPTURE_INTENT,                   // enum         | public
+    ANDROID_CONTROL_EFFECT_MODE,                      // enum         | public
+    ANDROID_CONTROL_MODE,                             // enum         | public
+    ANDROID_CONTROL_SCENE_MODE,                       // enum         | public
+    ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,         // enum         | public
+    ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,   // byte[]       | public
+    ANDROID_CONTROL_AE_AVAILABLE_MODES,               // byte[]       | system
+    ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,   // int32[]      | public
+    ANDROID_CONTROL_AE_COMPENSATION_RANGE,            // int32[]      | public
+    ANDROID_CONTROL_AE_COMPENSATION_STEP,             // rational     | public
+    ANDROID_CONTROL_AF_AVAILABLE_MODES,               // byte[]       | public
+    ANDROID_CONTROL_AVAILABLE_EFFECTS,                // byte[]       | public
+    ANDROID_CONTROL_AVAILABLE_SCENE_MODES,            // byte[]       | public
     ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
-    ANDROID_CONTROL_AWB_AVAILABLE_MODES,
-    ANDROID_CONTROL_MAX_REGIONS,
-    ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
-    ANDROID_CONTROL_AE_PRECAPTURE_ID,
-    ANDROID_CONTROL_AE_STATE,
-    ANDROID_CONTROL_AF_STATE,
-    ANDROID_CONTROL_AF_TRIGGER_ID,
-    ANDROID_CONTROL_AWB_STATE,
+                                                      // byte[]       | public
+    ANDROID_CONTROL_AWB_AVAILABLE_MODES,              // byte[]       | public
+    ANDROID_CONTROL_MAX_REGIONS,                      // int32        | public
+    ANDROID_CONTROL_SCENE_MODE_OVERRIDES,             // byte[]       | system
+    ANDROID_CONTROL_AE_PRECAPTURE_ID,                 // int32        | hidden
+    ANDROID_CONTROL_AE_STATE,                         // enum         | public
+    ANDROID_CONTROL_AF_STATE,                         // enum         | public
+    ANDROID_CONTROL_AF_TRIGGER_ID,                    // int32        | hidden
+    ANDROID_CONTROL_AWB_STATE,                        // enum         | public
     ANDROID_CONTROL_END,
 
-    ANDROID_DEMOSAIC_MODE          = ANDROID_DEMOSAIC_START,
+    ANDROID_DEMOSAIC_MODE =                           // enum         | system
+            ANDROID_DEMOSAIC_START,
     ANDROID_DEMOSAIC_END,
 
-    ANDROID_EDGE_MODE              = ANDROID_EDGE_START,
-    ANDROID_EDGE_STRENGTH,
+    ANDROID_EDGE_MODE =                               // enum         | public
+            ANDROID_EDGE_START,
+    ANDROID_EDGE_STRENGTH,                            // byte         | system
     ANDROID_EDGE_END,
 
-    ANDROID_FLASH_FIRING_POWER     = ANDROID_FLASH_START,
-    ANDROID_FLASH_FIRING_TIME,
-    ANDROID_FLASH_MODE,
-    ANDROID_FLASH_COLOR_TEMPERATURE,
-    ANDROID_FLASH_MAX_ENERGY,
-    ANDROID_FLASH_STATE,
+    ANDROID_FLASH_FIRING_POWER =                      // byte         | system
+            ANDROID_FLASH_START,
+    ANDROID_FLASH_FIRING_TIME,                        // int64        | system
+    ANDROID_FLASH_MODE,                               // enum         | public
+    ANDROID_FLASH_COLOR_TEMPERATURE,                  // byte         | system
+    ANDROID_FLASH_MAX_ENERGY,                         // byte         | system
+    ANDROID_FLASH_STATE,                              // enum         | public
     ANDROID_FLASH_END,
 
-    ANDROID_FLASH_INFO_AVAILABLE   = ANDROID_FLASH_INFO_START,
-    ANDROID_FLASH_INFO_CHARGE_DURATION,
+    ANDROID_FLASH_INFO_AVAILABLE =                    // byte         | public
+            ANDROID_FLASH_INFO_START,
+    ANDROID_FLASH_INFO_CHARGE_DURATION,               // int64        | system
     ANDROID_FLASH_INFO_END,
 
-    ANDROID_GEOMETRIC_MODE         = ANDROID_GEOMETRIC_START,
-    ANDROID_GEOMETRIC_STRENGTH,
+    ANDROID_GEOMETRIC_MODE =                          // enum         | system
+            ANDROID_GEOMETRIC_START,
+    ANDROID_GEOMETRIC_STRENGTH,                       // byte         | system
     ANDROID_GEOMETRIC_END,
 
-    ANDROID_HOT_PIXEL_MODE         = ANDROID_HOT_PIXEL_START,
+    ANDROID_HOT_PIXEL_MODE =                          // enum         | system
+            ANDROID_HOT_PIXEL_START,
     ANDROID_HOT_PIXEL_END,
 
-    ANDROID_HOT_PIXEL_INFO_MAP     = ANDROID_HOT_PIXEL_INFO_START,
+    ANDROID_HOT_PIXEL_INFO_MAP =                      // int32[]      | system
+            ANDROID_HOT_PIXEL_INFO_START,
     ANDROID_HOT_PIXEL_INFO_END,
 
-    ANDROID_JPEG_GPS_COORDINATES   = ANDROID_JPEG_START,
-    ANDROID_JPEG_GPS_PROCESSING_METHOD,
-    ANDROID_JPEG_GPS_TIMESTAMP,
-    ANDROID_JPEG_ORIENTATION,
-    ANDROID_JPEG_QUALITY,
-    ANDROID_JPEG_THUMBNAIL_QUALITY,
-    ANDROID_JPEG_THUMBNAIL_SIZE,
-    ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-    ANDROID_JPEG_MAX_SIZE,
-    ANDROID_JPEG_SIZE,
+    ANDROID_JPEG_GPS_COORDINATES =                    // double[]     | public
+            ANDROID_JPEG_START,
+    ANDROID_JPEG_GPS_PROCESSING_METHOD,               // byte         | public
+    ANDROID_JPEG_GPS_TIMESTAMP,                       // int64        | public
+    ANDROID_JPEG_ORIENTATION,                         // int32        | public
+    ANDROID_JPEG_QUALITY,                             // byte         | public
+    ANDROID_JPEG_THUMBNAIL_QUALITY,                   // byte         | public
+    ANDROID_JPEG_THUMBNAIL_SIZE,                      // int32[]      | public
+    ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,           // int32[]      | public
+    ANDROID_JPEG_MAX_SIZE,                            // int32        | system
+    ANDROID_JPEG_SIZE,                                // int32        | system
     ANDROID_JPEG_END,
 
-    ANDROID_LENS_APERTURE          = ANDROID_LENS_START,
-    ANDROID_LENS_FILTER_DENSITY,
-    ANDROID_LENS_FOCAL_LENGTH,
-    ANDROID_LENS_FOCUS_DISTANCE,
-    ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
-    ANDROID_LENS_FACING,
-    ANDROID_LENS_OPTICAL_AXIS_ANGLE,
-    ANDROID_LENS_POSITION,
-    ANDROID_LENS_FOCUS_RANGE,
-    ANDROID_LENS_STATE,
+    ANDROID_LENS_APERTURE =                           // float        | public
+            ANDROID_LENS_START,
+    ANDROID_LENS_FILTER_DENSITY,                      // float        | public
+    ANDROID_LENS_FOCAL_LENGTH,                        // float        | public
+    ANDROID_LENS_FOCUS_DISTANCE,                      // float        | public
+    ANDROID_LENS_OPTICAL_STABILIZATION_MODE,          // enum         | public
+    ANDROID_LENS_FACING,                              // enum         | public
+    ANDROID_LENS_OPTICAL_AXIS_ANGLE,                  // float[]      | system
+    ANDROID_LENS_POSITION,                            // float[]      | system
+    ANDROID_LENS_FOCUS_RANGE,                         // float[]      | public
+    ANDROID_LENS_STATE,                               // enum         | public
     ANDROID_LENS_END,
 
-    ANDROID_LENS_INFO_AVAILABLE_APERTURES
-                                   = ANDROID_LENS_INFO_START,
-    ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
-    ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
-    ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
-    ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP,
-    ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE,
-    ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
-    ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
-    ANDROID_LENS_INFO_SHADING_MAP,
-    ANDROID_LENS_INFO_SHADING_MAP_SIZE,
+    ANDROID_LENS_INFO_AVAILABLE_APERTURES =           // float[]      | public
+            ANDROID_LENS_INFO_START,
+    ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,     // float[]      | public
+    ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,        // float[]      | public
+    ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,// byte[]       | public
+    ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP,       // float[]      | system
+    ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE,  // int32[]      | system
+    ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,            // float        | public
+    ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,         // float        | public
+    ANDROID_LENS_INFO_SHADING_MAP_SIZE,               // int32[]      | public
     ANDROID_LENS_INFO_END,
 
-    ANDROID_NOISE_REDUCTION_MODE   = ANDROID_NOISE_REDUCTION_START,
-    ANDROID_NOISE_REDUCTION_STRENGTH,
+    ANDROID_NOISE_REDUCTION_MODE =                    // enum         | public
+            ANDROID_NOISE_REDUCTION_START,
+    ANDROID_NOISE_REDUCTION_STRENGTH,                 // byte         | system
     ANDROID_NOISE_REDUCTION_END,
 
-    ANDROID_QUIRKS_METERING_CROP_REGION
-                                   = ANDROID_QUIRKS_START,
-    ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
-    ANDROID_QUIRKS_USE_ZSL_FORMAT,
+    ANDROID_QUIRKS_METERING_CROP_REGION =             // byte         | system
+            ANDROID_QUIRKS_START,
+    ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,              // byte         | system
+    ANDROID_QUIRKS_USE_ZSL_FORMAT,                    // byte         | system
     ANDROID_QUIRKS_END,
 
-    ANDROID_REQUEST_FRAME_COUNT    = ANDROID_REQUEST_START,
-    ANDROID_REQUEST_ID,
-    ANDROID_REQUEST_INPUT_STREAMS,
-    ANDROID_REQUEST_METADATA_MODE,
-    ANDROID_REQUEST_OUTPUT_STREAMS,
-    ANDROID_REQUEST_TYPE,
-    ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
-    ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS,
+    ANDROID_REQUEST_FRAME_COUNT =                     // int32        | public
+            ANDROID_REQUEST_START,
+    ANDROID_REQUEST_ID,                               // int32        | hidden
+    ANDROID_REQUEST_INPUT_STREAMS,                    // int32[]      | system
+    ANDROID_REQUEST_METADATA_MODE,                    // enum         | system
+    ANDROID_REQUEST_OUTPUT_STREAMS,                   // int32[]      | system
+    ANDROID_REQUEST_TYPE,                             // enum         | system
+    ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,           // int32[]      | public
+    ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS,        // int32[]      | system
     ANDROID_REQUEST_END,
 
-    ANDROID_SCALER_CROP_REGION     = ANDROID_SCALER_START,
-    ANDROID_SCALER_AVAILABLE_FORMATS,
-    ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
-    ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
-    ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
-    ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
-    ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
-    ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
-    ANDROID_SCALER_AVAILABLE_RAW_SIZES,
+    ANDROID_SCALER_CROP_REGION =                      // int32[]      | public
+            ANDROID_SCALER_START,
+    ANDROID_SCALER_AVAILABLE_FORMATS,                 // enum[]       | public
+    ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,      // int64[]      | public
+    ANDROID_SCALER_AVAILABLE_JPEG_SIZES,              // int32[]      | public
+    ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,        // float        | public
+    ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, // int64[]      | public
+    ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,         // int32[]      | public
+    ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,       // int64[]      | system
+    ANDROID_SCALER_AVAILABLE_RAW_SIZES,               // int32[]      | system
     ANDROID_SCALER_END,
 
-    ANDROID_SENSOR_EXPOSURE_TIME   = ANDROID_SENSOR_START,
-    ANDROID_SENSOR_FRAME_DURATION,
-    ANDROID_SENSOR_SENSITIVITY,
-    ANDROID_SENSOR_BASE_GAIN_FACTOR,
-    ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
-    ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
-    ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
-    ANDROID_SENSOR_COLOR_TRANSFORM1,
-    ANDROID_SENSOR_COLOR_TRANSFORM2,
-    ANDROID_SENSOR_FORWARD_MATRIX1,
-    ANDROID_SENSOR_FORWARD_MATRIX2,
-    ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
-    ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS,
-    ANDROID_SENSOR_ORIENTATION,
-    ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
-    ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
-    ANDROID_SENSOR_TIMESTAMP,
+    ANDROID_SENSOR_EXPOSURE_TIME =                    // int64        | public
+            ANDROID_SENSOR_START,
+    ANDROID_SENSOR_FRAME_DURATION,                    // int64        | public
+    ANDROID_SENSOR_SENSITIVITY,                       // int32        | public
+    ANDROID_SENSOR_BASE_GAIN_FACTOR,                  // rational     | public
+    ANDROID_SENSOR_BLACK_LEVEL_PATTERN,               // int32[]      | system
+    ANDROID_SENSOR_CALIBRATION_TRANSFORM1,            // rational[]   | system
+    ANDROID_SENSOR_CALIBRATION_TRANSFORM2,            // rational[]   | system
+    ANDROID_SENSOR_COLOR_TRANSFORM1,                  // rational[]   | system
+    ANDROID_SENSOR_COLOR_TRANSFORM2,                  // rational[]   | system
+    ANDROID_SENSOR_FORWARD_MATRIX1,                   // rational[]   | system
+    ANDROID_SENSOR_FORWARD_MATRIX2,                   // rational[]   | system
+    ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,            // int32        | public
+    ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS,          // float[]      | system
+    ANDROID_SENSOR_ORIENTATION,                       // int32        | public
+    ANDROID_SENSOR_REFERENCE_ILLUMINANT1,             // enum         | system
+    ANDROID_SENSOR_REFERENCE_ILLUMINANT2,             // byte         | system
+    ANDROID_SENSOR_TIMESTAMP,                         // int64        | public
+    ANDROID_SENSOR_TEMPERATURE,                       // float        | public
     ANDROID_SENSOR_END,
 
-    ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE
-                                   = ANDROID_SENSOR_INFO_START,
-    ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES,
-    ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
-    ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
-    ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
-    ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
-    ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
-    ANDROID_SENSOR_INFO_WHITE_LEVEL,
+    ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE =           // int32[]      | public
+            ANDROID_SENSOR_INFO_START,
+    ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,            // int32[]      | public
+    ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,     // enum         | system
+    ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,          // int64[]      | public
+    ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,           // int64        | public
+    ANDROID_SENSOR_INFO_PHYSICAL_SIZE,                // float[]      | public
+    ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,             // int32[]      | system
+    ANDROID_SENSOR_INFO_WHITE_LEVEL,                  // int32        | system
     ANDROID_SENSOR_INFO_END,
 
-    ANDROID_SHADING_MODE           = ANDROID_SHADING_START,
-    ANDROID_SHADING_STRENGTH,
+    ANDROID_SHADING_MODE =                            // enum         | system
+            ANDROID_SHADING_START,
+    ANDROID_SHADING_STRENGTH,                         // byte         | system
     ANDROID_SHADING_END,
 
-    ANDROID_STATISTICS_FACE_DETECT_MODE
-                                   = ANDROID_STATISTICS_START,
-    ANDROID_STATISTICS_HISTOGRAM_MODE,
-    ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
-    ANDROID_STATISTICS_FACE_IDS,
-    ANDROID_STATISTICS_FACE_LANDMARKS,
-    ANDROID_STATISTICS_FACE_RECTANGLES,
-    ANDROID_STATISTICS_FACE_SCORES,
-    ANDROID_STATISTICS_HISTOGRAM,
-    ANDROID_STATISTICS_SHARPNESS_MAP,
+    ANDROID_STATISTICS_FACE_DETECT_MODE =             // enum         | public
+            ANDROID_STATISTICS_START,
+    ANDROID_STATISTICS_HISTOGRAM_MODE,                // enum         | system
+    ANDROID_STATISTICS_SHARPNESS_MAP_MODE,            // enum         | system
+    ANDROID_STATISTICS_FACE_IDS,                      // int32[]      | public
+    ANDROID_STATISTICS_FACE_LANDMARKS,                // int32[]      | public
+    ANDROID_STATISTICS_FACE_RECTANGLES,               // int32[]      | public
+    ANDROID_STATISTICS_FACE_SCORES,                   // byte[]       | public
+    ANDROID_STATISTICS_HISTOGRAM,                     // int32[]      | system
+    ANDROID_STATISTICS_SHARPNESS_MAP,                 // int32[]      | system
+    ANDROID_STATISTICS_LENS_SHADING_MAP,              // float[]      | public
+    ANDROID_STATISTICS_PREDICTED_COLOR_GAINS,         // float[]      | public
+    ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM,     // rational[]   | public
+    ANDROID_STATISTICS_SCENE_FLICKER,                 // enum         | public
+    ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,         // enum         | public
     ANDROID_STATISTICS_END,
 
-    ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES
-                                   = ANDROID_STATISTICS_INFO_START,
-    ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
-    ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
-    ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
-    ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
-    ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
+    ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES = 
+                                                      // byte[]       | public
+            ANDROID_STATISTICS_INFO_START,
+    ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,   // int32        | system
+    ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,           // int32        | public
+    ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,      // int32        | system
+    ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,  // int32        | system
+    ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,       // int32[]      | system
     ANDROID_STATISTICS_INFO_END,
 
-    ANDROID_TONEMAP_CURVE_BLUE     = ANDROID_TONEMAP_START,
-    ANDROID_TONEMAP_CURVE_GREEN,
-    ANDROID_TONEMAP_CURVE_RED,
-    ANDROID_TONEMAP_MODE,
-    ANDROID_TONEMAP_MAX_CURVE_POINTS,
+    ANDROID_TONEMAP_CURVE_BLUE =                      // float[]      | public
+            ANDROID_TONEMAP_START,
+    ANDROID_TONEMAP_CURVE_GREEN,                      // float[]      | public
+    ANDROID_TONEMAP_CURVE_RED,                        // float[]      | public
+    ANDROID_TONEMAP_MODE,                             // enum         | public
+    ANDROID_TONEMAP_MAX_CURVE_POINTS,                 // int32        | public
     ANDROID_TONEMAP_END,
 
-    ANDROID_LED_TRANSMIT           = ANDROID_LED_START,
-    ANDROID_LED_AVAILABLE_LEDS,
+    ANDROID_LED_TRANSMIT =                            // enum         | hidden
+            ANDROID_LED_START,
+    ANDROID_LED_AVAILABLE_LEDS,                       // enum[]       | hidden
     ANDROID_LED_END,
 
-    ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL
-                                   = ANDROID_INFO_START,
+    ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL =           // enum         | public
+            ANDROID_INFO_START,
     ANDROID_INFO_END,
 
+    ANDROID_BLACK_LEVEL_LOCK =                        // enum         | public
+            ANDROID_BLACK_LEVEL_START,
+    ANDROID_BLACK_LEVEL_END,
+
 } camera_metadata_tag_t;
 
 /**
@@ -466,6 +497,7 @@ typedef enum camera_metadata_enum_android_control_af_state {
     ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN,
     ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED,
     ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED,
+    ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED,
 } camera_metadata_enum_android_control_af_state_t;
 
 // ANDROID_CONTROL_AWB_STATE
@@ -542,6 +574,7 @@ typedef enum camera_metadata_enum_android_lens_facing {
 // ANDROID_LENS_STATE
 typedef enum camera_metadata_enum_android_lens_state {
     ANDROID_LENS_STATE_STATIONARY,
+    ANDROID_LENS_STATE_MOVING,
 } camera_metadata_enum_android_lens_state_t;
 
 
@@ -640,6 +673,19 @@ typedef enum camera_metadata_enum_android_statistics_sharpness_map_mode {
     ANDROID_STATISTICS_SHARPNESS_MAP_MODE_ON,
 } camera_metadata_enum_android_statistics_sharpness_map_mode_t;
 
+// ANDROID_STATISTICS_SCENE_FLICKER
+typedef enum camera_metadata_enum_android_statistics_scene_flicker {
+    ANDROID_STATISTICS_SCENE_FLICKER_NONE,
+    ANDROID_STATISTICS_SCENE_FLICKER_50HZ,
+    ANDROID_STATISTICS_SCENE_FLICKER_60HZ,
+} camera_metadata_enum_android_statistics_scene_flicker_t;
+
+// ANDROID_STATISTICS_LENS_SHADING_MAP_MODE
+typedef enum camera_metadata_enum_android_statistics_lens_shading_map_mode {
+    ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF,
+    ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON,
+} camera_metadata_enum_android_statistics_lens_shading_map_mode_t;
+
 
 
 // ANDROID_TONEMAP_MODE
@@ -669,3 +715,10 @@ typedef enum camera_metadata_enum_android_info_supported_hardware_level {
 } camera_metadata_enum_android_info_supported_hardware_level_t;
 
 
+// ANDROID_BLACK_LEVEL_LOCK
+typedef enum camera_metadata_enum_android_black_level_lock {
+    ANDROID_BLACK_LEVEL_LOCK_OFF,
+    ANDROID_BLACK_LEVEL_LOCK_ON,
+} camera_metadata_enum_android_black_level_lock_t;
+
+
diff --git a/camera/src/camera_metadata.c b/camera/src/camera_metadata.c
index 76fca9ae..a413f66c 100644
--- a/camera/src/camera_metadata.c
+++ b/camera/src/camera_metadata.c
@@ -431,7 +431,8 @@ int validate_camera_metadata_structure(const camera_metadata_t *metadata,
         } else if (entry.count == 0) {
             if (entry.data.offset != 0) {
                 ALOGE("%s: Entry index %u had 0 items, but offset was non-0 "
-                     "(%u)", __FUNCTION__, i, entry.data.offset);
+                     "(%u), tag name: %s", __FUNCTION__, i, entry.data.offset,
+                        get_camera_metadata_tag_name(entry.tag) ?: "unknown");
                 return ERROR;
             }
         } // else data stored inline, so we look at value which can be anything.
@@ -516,6 +517,7 @@ static int add_camera_metadata_entry_raw(camera_metadata_t *dst,
     size_t data_payload_bytes =
             data_count * camera_metadata_type_size[type];
     camera_metadata_buffer_entry_t *entry = get_entries(dst) + dst->entry_count;
+    memset(entry, 0, sizeof(camera_metadata_buffer_entry_t));
     entry->tag = tag;
     entry->type = type;
     entry->count = data_count;
diff --git a/camera/src/camera_metadata_tag_info.c b/camera/src/camera_metadata_tag_info.c
index 65ffe671..1a0dc115 100644
--- a/camera/src/camera_metadata_tag_info.c
+++ b/camera/src/camera_metadata_tag_info.c
@@ -55,6 +55,7 @@ const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {
     [ANDROID_TONEMAP]              = "android.tonemap",
     [ANDROID_LED]                  = "android.led",
     [ANDROID_INFO]                 = "android.info",
+    [ANDROID_BLACK_LEVEL]          = "android.blackLevel",
 };
 
 unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
@@ -106,6 +107,8 @@ unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
                                        ANDROID_LED_END },
     [ANDROID_INFO]                 = { ANDROID_INFO_START,
                                        ANDROID_INFO_END },
+    [ANDROID_BLACK_LEVEL]          = { ANDROID_BLACK_LEVEL_START,
+                                       ANDROID_BLACK_LEVEL_END },
 };
 
 static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -
@@ -113,7 +116,10 @@ static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -
     [ ANDROID_COLOR_CORRECTION_MODE - ANDROID_COLOR_CORRECTION_START ] =
     { "mode",                          TYPE_BYTE   },
     [ ANDROID_COLOR_CORRECTION_TRANSFORM - ANDROID_COLOR_CORRECTION_START ] =
-    { "transform",                     TYPE_FLOAT  },
+    { "transform",                     TYPE_RATIONAL
+                },
+    [ ANDROID_COLOR_CORRECTION_GAINS - ANDROID_COLOR_CORRECTION_START ] =
+    { "gains",                         TYPE_FLOAT  },
 };
 
 static tag_info_t android_control[ANDROID_CONTROL_END -
@@ -316,8 +322,6 @@ static tag_info_t android_lens_info[ANDROID_LENS_INFO_END -
     { "hyperfocalDistance",            TYPE_FLOAT  },
     [ ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE - ANDROID_LENS_INFO_START ] =
     { "minimumFocusDistance",          TYPE_FLOAT  },
-    [ ANDROID_LENS_INFO_SHADING_MAP - ANDROID_LENS_INFO_START ] =
-    { "shadingMap",                    TYPE_FLOAT  },
     [ ANDROID_LENS_INFO_SHADING_MAP_SIZE - ANDROID_LENS_INFO_START ] =
     { "shadingMapSize",                TYPE_INT32  },
 };
@@ -347,11 +351,11 @@ static tag_info_t android_request[ANDROID_REQUEST_END -
     [ ANDROID_REQUEST_ID - ANDROID_REQUEST_START ] =
     { "id",                            TYPE_INT32  },
     [ ANDROID_REQUEST_INPUT_STREAMS - ANDROID_REQUEST_START ] =
-    { "inputStreams",                  TYPE_BYTE   },
+    { "inputStreams",                  TYPE_INT32  },
     [ ANDROID_REQUEST_METADATA_MODE - ANDROID_REQUEST_START ] =
     { "metadataMode",                  TYPE_BYTE   },
     [ ANDROID_REQUEST_OUTPUT_STREAMS - ANDROID_REQUEST_START ] =
-    { "outputStreams",                 TYPE_BYTE   },
+    { "outputStreams",                 TYPE_INT32  },
     [ ANDROID_REQUEST_TYPE - ANDROID_REQUEST_START ] =
     { "type",                          TYPE_BYTE   },
     [ ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS - ANDROID_REQUEST_START ] =
@@ -426,14 +430,16 @@ static tag_info_t android_sensor[ANDROID_SENSOR_END -
     { "referenceIlluminant2",          TYPE_BYTE   },
     [ ANDROID_SENSOR_TIMESTAMP - ANDROID_SENSOR_START ] =
     { "timestamp",                     TYPE_INT64  },
+    [ ANDROID_SENSOR_TEMPERATURE - ANDROID_SENSOR_START ] =
+    { "temperature",                   TYPE_FLOAT  },
 };
 
 static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -
         ANDROID_SENSOR_INFO_START] = {
     [ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE - ANDROID_SENSOR_INFO_START ] =
     { "activeArraySize",               TYPE_INT32  },
-    [ ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES - ANDROID_SENSOR_INFO_START ] =
-    { "availableSensitivities",        TYPE_INT32  },
+    [ ANDROID_SENSOR_INFO_SENSITIVITY_RANGE - ANDROID_SENSOR_INFO_START ] =
+    { "sensitivityRange",              TYPE_INT32  },
     [ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT - ANDROID_SENSOR_INFO_START ] =
     { "colorFilterArrangement",        TYPE_BYTE   },
     [ ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE - ANDROID_SENSOR_INFO_START ] =
@@ -476,6 +482,17 @@ static tag_info_t android_statistics[ANDROID_STATISTICS_END -
     { "histogram",                     TYPE_INT32  },
     [ ANDROID_STATISTICS_SHARPNESS_MAP - ANDROID_STATISTICS_START ] =
     { "sharpnessMap",                  TYPE_INT32  },
+    [ ANDROID_STATISTICS_LENS_SHADING_MAP - ANDROID_STATISTICS_START ] =
+    { "lensShadingMap",                TYPE_FLOAT  },
+    [ ANDROID_STATISTICS_PREDICTED_COLOR_GAINS - ANDROID_STATISTICS_START ] =
+    { "predictedColorGains",           TYPE_FLOAT  },
+    [ ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM - ANDROID_STATISTICS_START ] =
+    { "predictedColorTransform",       TYPE_RATIONAL
+                },
+    [ ANDROID_STATISTICS_SCENE_FLICKER - ANDROID_STATISTICS_START ] =
+    { "sceneFlicker",                  TYPE_BYTE   },
+    [ ANDROID_STATISTICS_LENS_SHADING_MAP_MODE - ANDROID_STATISTICS_START ] =
+    { "lensShadingMapMode",            TYPE_BYTE   },
 };
 
 static tag_info_t android_statistics_info[ANDROID_STATISTICS_INFO_END -
@@ -522,6 +539,12 @@ static tag_info_t android_info[ANDROID_INFO_END -
     { "supportedHardwareLevel",        TYPE_BYTE   },
 };
 
+static tag_info_t android_black_level[ANDROID_BLACK_LEVEL_END -
+        ANDROID_BLACK_LEVEL_START] = {
+    [ ANDROID_BLACK_LEVEL_LOCK - ANDROID_BLACK_LEVEL_START ] =
+    { "lock",                          TYPE_BYTE   },
+};
+
 
 tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
     android_color_correction,
@@ -548,6 +571,7 @@ tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
     android_tonemap,
     android_led,
     android_info,
+    android_black_level,
 };
 
 int camera_metadata_enum_snprint(uint32_t tag,
@@ -580,6 +604,9 @@ int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_COLOR_CORRECTION_TRANSFORM: {
             break;
         }
+        case ANDROID_COLOR_CORRECTION_GAINS: {
+            break;
+        }
 
         case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {
             switch (value) {
@@ -1063,6 +1090,10 @@ int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "NOT_FOCUSED_LOCKED";
                     ret = 0;
                     break;
+                case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
+                    msg = "PASSIVE_UNFOCUSED";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1331,6 +1362,10 @@ int camera_metadata_enum_snprint(uint32_t tag,
                     msg = "STATIONARY";
                     ret = 0;
                     break;
+                case ANDROID_LENS_STATE_MOVING:
+                    msg = "MOVING";
+                    ret = 0;
+                    break;
                 default:
                     msg = "error: enum value out of range";
             }
@@ -1361,9 +1396,6 @@ int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE: {
             break;
         }
-        case ANDROID_LENS_INFO_SHADING_MAP: {
-            break;
-        }
         case ANDROID_LENS_INFO_SHADING_MAP_SIZE: {
             break;
         }
@@ -1637,11 +1669,14 @@ int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_SENSOR_TIMESTAMP: {
             break;
         }
+        case ANDROID_SENSOR_TEMPERATURE: {
+            break;
+        }
 
         case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {
             break;
         }
-        case ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES: {
+        case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {
             break;
         }
         case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {
@@ -1777,6 +1812,49 @@ int camera_metadata_enum_snprint(uint32_t tag,
         case ANDROID_STATISTICS_SHARPNESS_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: {
+            switch (value) {
+                case ANDROID_STATISTICS_SCENE_FLICKER_NONE:
+                    msg = "NONE";
+                    ret = 0;
+                    break;
+                case ANDROID_STATISTICS_SCENE_FLICKER_50HZ:
+                    msg = "50HZ";
+                    ret = 0;
+                    break;
+                case ANDROID_STATISTICS_SCENE_FLICKER_60HZ:
+                    msg = "60HZ";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+        case ANDROID_STATISTICS_LENS_SHADING_MAP_MODE: {
+            switch (value) {
+                case ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
 
         case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {
             break;
@@ -1872,6 +1950,22 @@ int camera_metadata_enum_snprint(uint32_t tag,
             break;
         }
 
+        case ANDROID_BLACK_LEVEL_LOCK: {
+            switch (value) {
+                case ANDROID_BLACK_LEVEL_LOCK_OFF:
+                    msg = "OFF";
+                    ret = 0;
+                    break;
+                case ANDROID_BLACK_LEVEL_LOCK_ON:
+                    msg = "ON";
+                    ret = 0;
+                    break;
+                default:
+                    msg = "error: enum value out of range";
+            }
+            break;
+        }
+
     }
 
     strncpy(dst, msg, size - 1);
diff --git a/camera/tests/camera_metadata_tests_fake_vendor.h b/camera/tests/camera_metadata_tests_fake_vendor.h
index 8e087762..74e85ee8 100644
--- a/camera/tests/camera_metadata_tests_fake_vendor.h
+++ b/camera/tests/camera_metadata_tests_fake_vendor.h
@@ -110,11 +110,15 @@ const char *get_fakevendor_tag_name(const vendor_tag_query_ops_t *v,
         uint32_t tag);
 int get_fakevendor_tag_type(const vendor_tag_query_ops_t *v,
         uint32_t tag);
+int get_fakevendor_tag_count(const vendor_tag_query_ops_t *v);
+void get_fakevendor_tags(const vendor_tag_query_ops_t *v, uint32_t *tag_array);
 
 static const vendor_tag_query_ops_t fakevendor_query_ops = {
     get_fakevendor_section_name,
     get_fakevendor_tag_name,
-    get_fakevendor_tag_type
+    get_fakevendor_tag_type,
+    get_fakevendor_tag_count,
+    get_fakevendor_tags
 };
 
 const char *get_fakevendor_section_name(const vendor_tag_query_ops_t *v,
@@ -149,5 +153,32 @@ int get_fakevendor_tag_type(const vendor_tag_query_ops_t *v,
     return fakevendor_tag_info[tag_section][tag_index].tag_type;
 }
 
+int get_fakevendor_tag_count(const vendor_tag_query_ops_t *v) {
+    int section;
+    unsigned int start, end;
+    int count = 0;
+
+    if (v != &fakevendor_query_ops) return -1;
+    for (section = 0; section < FAKEVENDOR_SECTION_COUNT; section++) {
+        start = fakevendor_section_bounds[section][0];
+        end = fakevendor_section_bounds[section][1];
+        count += end - start;
+    }
+    return count;
+}
+
+void get_fakevendor_tags(const vendor_tag_query_ops_t *v, uint32_t *tag_array) {
+    int section;
+    unsigned int start, end, tag;
+
+    if (v != &fakevendor_query_ops || tag_array == NULL) return;
+    for (section = 0; section < FAKEVENDOR_SECTION_COUNT; section++) {
+        start = fakevendor_section_bounds[section][0];
+        end = fakevendor_section_bounds[section][1];
+        for (tag = start; tag < end; tag++) {
+            *tag_array++ = tag;
+        }
+    }
+}
 
 #endif