Camera: Update emulator camera v3 HAL to v3.3, module to v2.3

Many updates to meet requirements of v3.3, including quite a few
of metadata updates.

Not all features promised by the metadata are actually wired up,
though.

Also adds initial support for capability selection based on system
properties, though the selection isn't reflected in behavior
outside the capability field for the most part.

Sufficient to make the AOSP camera app run (and even record video),
but not sufficient to pass all the CTS tests yet.

Bug: 20537722

Change-Id: I0776fe361492402189569b7ab5c2f37b6900ffc5

10 files changed, 664 insertions, 412 deletions

diff --git a/camera/EmulatedCamera3.cpp b/camera/EmulatedCamera3.cpp
index 47de44f..e9110cc 100644
--- a/camera/EmulatedCamera3.cpp
+++ b/camera/EmulatedCamera3.cpp
@@ -41,7 +41,7 @@ namespace android {
 EmulatedCamera3::EmulatedCamera3(int cameraId,
         struct hw_module_t* module):
         EmulatedBaseCamera(cameraId,
-                CAMERA_DEVICE_API_VERSION_3_0,
+                CAMERA_DEVICE_API_VERSION_3_3,
                 &common,
                 module),
         mStatus(STATUS_ERROR)
@@ -51,13 +51,6 @@ EmulatedCamera3::EmulatedCamera3(int cameraId,
 
     mCallbackOps = NULL;
 
-    mVendorTagOps.get_camera_vendor_section_name =
-            EmulatedCamera3::get_camera_vendor_section_name;
-    mVendorTagOps.get_camera_vendor_tag_name =
-            EmulatedCamera3::get_camera_vendor_tag_name;
-    mVendorTagOps.get_camera_vendor_tag_type =
-            EmulatedCamera3::get_camera_vendor_tag_type;
-    mVendorTagOps.parent = this;
 }
 
 /* Destructs EmulatedCamera3 instance. */
@@ -156,21 +149,9 @@ status_t EmulatedCamera3::processCaptureRequest(
     return INVALID_OPERATION;
 }
 
-/** Custom tag query methods */
-
-const char* EmulatedCamera3::getVendorSectionName(uint32_t tag) {
-    ALOGE("%s: Not implemented", __FUNCTION__);
-    return NULL;
-}
-
-const char* EmulatedCamera3::getVendorTagName(uint32_t tag) {
-    ALOGE("%s: Not implemented", __FUNCTION__);
-    return NULL;
-}
-
-int EmulatedCamera3::getVendorTagType(uint32_t tag) {
+status_t EmulatedCamera3::flush() {
     ALOGE("%s: Not implemented", __FUNCTION__);
-    return -1;
+    return INVALID_OPERATION;
 }
 
 /** Debug methods */
@@ -241,39 +222,16 @@ const camera_metadata_t* EmulatedCamera3::construct_default_request_settings(
     return ec->constructDefaultRequestSettings(type);
 }
 
-void EmulatedCamera3::get_metadata_vendor_tag_ops(const camera3_device_t *d,
-        vendor_tag_query_ops_t *ops) {
-    ops->get_camera_vendor_section_name = get_camera_vendor_section_name;
-    ops->get_camera_vendor_tag_name = get_camera_vendor_tag_name;
-    ops->get_camera_vendor_tag_type = get_camera_vendor_tag_type;
-}
-
-const char* EmulatedCamera3::get_camera_vendor_section_name(
-        const vendor_tag_query_ops_t *v,
-        uint32_t tag) {
-    EmulatedCamera3* ec = static_cast<const TagOps*>(v)->parent;
-    return ec->getVendorSectionName(tag);
-}
-
-const char* EmulatedCamera3::get_camera_vendor_tag_name(
-        const vendor_tag_query_ops_t *v,
-        uint32_t tag) {
-    EmulatedCamera3* ec = static_cast<const TagOps*>(v)->parent;
-    return ec->getVendorTagName(tag);
-}
-
-int EmulatedCamera3::get_camera_vendor_tag_type(
-        const vendor_tag_query_ops_t *v,
-        uint32_t tag)  {
-    EmulatedCamera3* ec = static_cast<const TagOps*>(v)->parent;
-    return ec->getVendorTagType(tag);
-}
-
 void EmulatedCamera3::dump(const camera3_device_t *d, int fd) {
     EmulatedCamera3* ec = getInstance(d);
     ec->dump(fd);
 }
 
+int EmulatedCamera3::flush(const camera3_device_t *d) {
+    EmulatedCamera3* ec = getInstance(d);
+    return ec->flush();
+}
+
 int EmulatedCamera3::close(struct hw_device_t* device) {
     EmulatedCamera3* ec =
             static_cast<EmulatedCamera3*>(
@@ -288,11 +246,26 @@ int EmulatedCamera3::close(struct hw_device_t* device) {
 camera3_device_ops_t EmulatedCamera3::sDeviceOps = {
     EmulatedCamera3::initialize,
     EmulatedCamera3::configure_streams,
-    EmulatedCamera3::register_stream_buffers,
+    /* DEPRECATED: register_stream_buffers */ nullptr,
     EmulatedCamera3::construct_default_request_settings,
     EmulatedCamera3::process_capture_request,
-    EmulatedCamera3::get_metadata_vendor_tag_ops,
-    EmulatedCamera3::dump
+    /* DEPRECATED: get_metadata_vendor_tag_ops */ nullptr,
+    EmulatedCamera3::dump,
+    EmulatedCamera3::flush
+};
+
+const char* EmulatedCamera3::sAvailableCapabilitiesStrings[NUM_CAPABILITIES] = {
+    "BACKWARD_COMPATIBLE",
+    "MANUAL_SENSOR",
+    "MANUAL_POST_PROCESSING",
+    "RAW",
+    "PRIVATE_REPROCESSING",
+    "READ_SENSOR_SETTINGS",
+    "BURST_CAPTURE",
+    "YUV_REPROCESSING",
+    "DEPTH_OUTPUT",
+    "CONSTRAINED_HIGH_SPEED_VIDEO",
+    "FULL_LEVEL"
 };
 
 }; /* namespace android */
diff --git a/camera/EmulatedCamera3.h b/camera/EmulatedCamera3.h
index c1bddf6..9d2d7b2 100644
--- a/camera/EmulatedCamera3.h
+++ b/camera/EmulatedCamera3.h
@@ -54,6 +54,27 @@ public:
     /* Destructs EmulatedCamera2 instance. */
     virtual ~EmulatedCamera3();
 
+    /* List of all defined capabilities plus useful HW levels */
+    enum AvailableCapabilities {
+        BACKWARD_COMPATIBLE,
+        MANUAL_SENSOR,
+        MANUAL_POST_PROCESSING,
+        RAW,
+        PRIVATE_REPROCESSING,
+        READ_SENSOR_SETTINGS,
+        BURST_CAPTURE,
+        YUV_REPROCESSING,
+        DEPTH_OUTPUT,
+        CONSTRAINED_HIGH_SPEED_VIDEO,
+        // Levels
+        FULL_LEVEL,
+
+        NUM_CAPABILITIES
+    };
+
+    // Char strings for above enum, with size NUM_CAPABILITIES
+    static const char *sAvailableCapabilitiesStrings[];
+
     /****************************************************************************
      * Abstract API
      ***************************************************************************/
@@ -99,17 +120,12 @@ protected:
 
     virtual status_t processCaptureRequest(camera3_capture_request *request);
 
+    virtual status_t flush();
+
     /** Debug methods */
 
     virtual void dump(int fd);
 
-    /** Tag query methods */
-    virtual const char *getVendorSectionName(uint32_t tag);
-
-    virtual const char *getVendorTagName(uint32_t tag);
-
-    virtual int getVendorTagType(uint32_t tag);
-
     /****************************************************************************
      * Camera API callbacks as defined by camera3_device_ops structure.  See
      * hardware/libhardware/include/hardware/camera3.h for information on each
@@ -142,22 +158,10 @@ private:
     static int process_capture_request(const struct camera3_device *,
             camera3_capture_request_t *request);
 
-    /** Vendor metadata registration */
-    static void get_metadata_vendor_tag_ops(const camera3_device_t *,
-            vendor_tag_query_ops_t *ops);
-    // for get_metadata_vendor_tag_ops
-    static const char* get_camera_vendor_section_name(
-            const vendor_tag_query_ops_t *,
-            uint32_t tag);
-    static const char* get_camera_vendor_tag_name(
-            const vendor_tag_query_ops_t *,
-            uint32_t tag);
-    static int get_camera_vendor_tag_type(
-            const vendor_tag_query_ops_t *,
-            uint32_t tag);
-
     static void dump(const camera3_device_t *, int fd);
 
+    static int flush(const camera3_device_t *);
+
     /** For hw_device_t ops */
     static int close(struct hw_device_t* device);
 
@@ -166,11 +170,6 @@ private:
      ***************************************************************************/
   protected:
 
-    struct TagOps : public vendor_tag_query_ops {
-        EmulatedCamera3 *parent;
-    };
-    TagOps      mVendorTagOps;
-
     enum {
         // State at construction time, and after a device operation error
         STATUS_ERROR = 0,
diff --git a/camera/EmulatedCameraFactory.cpp b/camera/EmulatedCameraFactory.cpp
index 0a8ada7..586c9c6 100755
--- a/camera/EmulatedCameraFactory.cpp
+++ b/camera/EmulatedCameraFactory.cpp
@@ -259,6 +259,12 @@ int EmulatedCameraFactory::setCallbacks(
     return OK;
 }
 
+void EmulatedCameraFactory::getVendorTagOps(vendor_tag_ops_t* ops) {
+    ALOGV("%s: ops = %p", __FUNCTION__, ops);
+
+    // No vendor tags defined for emulator yet, so not touching ops
+}
+
 /****************************************************************************
  * Camera HAL API callbacks.
  ***************************************************************************/
@@ -302,6 +308,17 @@ int EmulatedCameraFactory::set_callbacks(
     return gEmulatedCameraFactory.setCallbacks(callbacks);
 }
 
+void EmulatedCameraFactory::get_vendor_tag_ops(vendor_tag_ops_t* ops)
+{
+    gEmulatedCameraFactory.getVendorTagOps(ops);
+}
+
+int EmulatedCameraFactory::open_legacy(const struct hw_module_t* module,
+        const char* id, uint32_t halVersion, struct hw_device_t** device) {
+    // Not supporting legacy open
+    return -ENOSYS;
+}
+
 /********************************************************************************
  * Internal API
  *******************************************************************************/
diff --git a/camera/EmulatedCameraFactory.h b/camera/EmulatedCameraFactory.h
index 470f5ea..3f19be1 100755
--- a/camera/EmulatedCameraFactory.h
+++ b/camera/EmulatedCameraFactory.h
@@ -80,6 +80,11 @@ public:
      */
     int setCallbacks(const camera_module_callbacks_t *callbacks);
 
+    /* Fill in vendor tags for the module
+     * This method is called in response to camera_module_t::get_vendor_tag_ops callback.
+     */
+    void getVendorTagOps(vendor_tag_ops_t* ops);
+
     /****************************************************************************
      * Camera HAL API callbacks.
      ***************************************************************************/
@@ -94,6 +99,13 @@ public:
     /* camera_module_t::set_callbacks callback entry point. */
     static int set_callbacks(const camera_module_callbacks_t *callbacks);
 
+    /* camera_module_t::get_vendor_tag_ops callback entry point */
+    static void get_vendor_tag_ops(vendor_tag_ops_t* ops);
+
+    /* camera_module_t::open_legacy callback entry point */
+    static int open_legacy(const struct hw_module_t* module, const char* id,
+            uint32_t halVersion, struct hw_device_t** device);
+
 private:
     /* hw_module_methods_t::open callback entry point. */
     static int device_open(const hw_module_t* module,
diff --git a/camera/EmulatedCameraHal.cpp b/camera/EmulatedCameraHal.cpp
index 802a5bb..b1f8b3a 100755
--- a/camera/EmulatedCameraHal.cpp
+++ b/camera/EmulatedCameraHal.cpp
@@ -31,7 +31,7 @@
 camera_module_t HAL_MODULE_INFO_SYM = {
     common: {
          tag:                HARDWARE_MODULE_TAG,
-         module_api_version: CAMERA_MODULE_API_VERSION_2_1,
+         module_api_version: CAMERA_MODULE_API_VERSION_2_3,
          hal_api_version:    HARDWARE_HAL_API_VERSION,
          id:                 CAMERA_HARDWARE_MODULE_ID,
          name:               "Emulated Camera Module",
@@ -43,4 +43,6 @@ camera_module_t HAL_MODULE_INFO_SYM = {
     get_number_of_cameras:  android::EmulatedCameraFactory::get_number_of_cameras,
     get_camera_info:        android::EmulatedCameraFactory::get_camera_info,
     set_callbacks:          android::EmulatedCameraFactory::set_callbacks,
+    get_vendor_tag_ops:     android::EmulatedCameraFactory::get_vendor_tag_ops,
+    open_legacy:            android::EmulatedCameraFactory::open_legacy
 };
diff --git a/camera/EmulatedFakeCamera2.cpp b/camera/EmulatedFakeCamera2.cpp
index 79658f1..d1beb92 100644
--- a/camera/EmulatedFakeCamera2.cpp
+++ b/camera/EmulatedFakeCamera2.cpp
@@ -55,7 +55,7 @@ const uint32_t EmulatedFakeCamera2::kAvailableRawSizes[2] = {
 };
 
 const uint64_t EmulatedFakeCamera2::kAvailableRawMinDurations[1] = {
-    Sensor::kFrameDurationRange[0]
+    static_cast<uint64_t>(Sensor::kFrameDurationRange[0])
 };
 
 const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesBack[4] = {
@@ -69,7 +69,7 @@ const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesFront[4] = {
 };
 
 const uint64_t EmulatedFakeCamera2::kAvailableProcessedMinDurations[1] = {
-    Sensor::kFrameDurationRange[0]
+    static_cast<uint64_t>(Sensor::kFrameDurationRange[0])
 };
 
 const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesBack[2] = {
@@ -84,7 +84,7 @@ const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesFront[2] = {
 
 
 const uint64_t EmulatedFakeCamera2::kAvailableJpegMinDurations[1] = {
-    Sensor::kFrameDurationRange[0]
+    static_cast<uint64_t>(Sensor::kFrameDurationRange[0])
 };
 
 
@@ -1455,15 +1455,15 @@ status_t EmulatedFakeCamera2::ReadoutThread::collectStatisticsMetadata(
     // the rectangles don't line up quite right.
     const size_t numFaces = 2;
     int32_t rects[numFaces * 4] = {
-            Sensor::kResolution[0] * 10 / 20,
-            Sensor::kResolution[1] * 15 / 20,
-            Sensor::kResolution[0] * 12 / 20,
-            Sensor::kResolution[1] * 17 / 20,
-
-            Sensor::kResolution[0] * 16 / 20,
-            Sensor::kResolution[1] * 15 / 20,
-            Sensor::kResolution[0] * 18 / 20,
-            Sensor::kResolution[1] * 17 / 20
+        static_cast<int32_t>(Sensor::kResolution[0] * 10 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 15 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 12 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 17 / 20),
+
+        static_cast<int32_t>(Sensor::kResolution[0] * 16 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 15 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 18 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 17 / 20)
     };
     // To simulate some kind of real detection going on, we jitter the rectangles on
     // each frame by a few pixels in each dimension.
@@ -1496,19 +1496,19 @@ status_t EmulatedFakeCamera2::ReadoutThread::collectStatisticsMetadata(
     // coordinates in order are (leftEyeX, leftEyeY, rightEyeX, rightEyeY,
     // mouthX, mouthY). The mapping is the same as the face rectangles.
     int32_t features[numFaces * 6] = {
-        Sensor::kResolution[0] * 10.5 / 20,
-        Sensor::kResolution[1] * 16 / 20,
-        Sensor::kResolution[0] * 11.5 / 20,
-        Sensor::kResolution[1] * 16 / 20,
-        Sensor::kResolution[0] * 11 / 20,
-        Sensor::kResolution[1] * 16.5 / 20,
-
-        Sensor::kResolution[0] * 16.5 / 20,
-        Sensor::kResolution[1] * 16 / 20,
-        Sensor::kResolution[0] * 17.5 / 20,
-        Sensor::kResolution[1] * 16 / 20,
-        Sensor::kResolution[0] * 17 / 20,
-        Sensor::kResolution[1] * 16.5 / 20,
+        static_cast<int32_t>(Sensor::kResolution[0] * 10.5 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 11.5 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 11 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16.5 / 20),
+
+        static_cast<int32_t>(Sensor::kResolution[0] * 16.5 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 17.5 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16 / 20),
+        static_cast<int32_t>(Sensor::kResolution[0] * 17 / 20),
+        static_cast<int32_t>(Sensor::kResolution[1] * 16.5 / 20),
     };
     // Jitter these a bit less than the rects
     for (size_t i = 0; i < numFaces * 6; i++) {
@@ -2134,8 +2134,10 @@ status_t EmulatedFakeCamera2::constructStaticInfo(
             &Sensor::kMaxRawValue, 1);
 
     static const int32_t blackLevelPattern[4] = {
-            Sensor::kBlackLevel, Sensor::kBlackLevel,
-            Sensor::kBlackLevel, Sensor::kBlackLevel
+        static_cast<int32_t>(Sensor::kBlackLevel),
+        static_cast<int32_t>(Sensor::kBlackLevel),
+        static_cast<int32_t>(Sensor::kBlackLevel),
+        static_cast<int32_t>(Sensor::kBlackLevel)
     };
     ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
             blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
@@ -2496,7 +2498,7 @@ status_t EmulatedFakeCamera2::constructDefaultRequest(
 
     /** android.scaler */
     static const int32_t cropRegion[3] = {
-        0, 0, Sensor::kResolution[0]
+        0, 0, static_cast<int32_t>(Sensor::kResolution[0])
     };
     ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
 
@@ -2583,7 +2585,10 @@ status_t EmulatedFakeCamera2::constructDefaultRequest(
     ADD_OR_SIZE(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
 
     static const int32_t controlRegions[5] = {
-        0, 0, Sensor::kResolution[0], Sensor::kResolution[1], 1000
+        0, 0,
+        static_cast<int32_t>(Sensor::kResolution[0]),
+        static_cast<int32_t>(Sensor::kResolution[1]),
+        1000
     };
     ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
 
diff --git a/camera/EmulatedFakeCamera3.cpp b/camera/EmulatedFakeCamera3.cpp
index 8821d90..fe5e26b 100644
--- a/camera/EmulatedFakeCamera3.cpp
+++ b/camera/EmulatedFakeCamera3.cpp
@@ -24,6 +24,7 @@
 //#define LOG_NDEBUG 0
 //#define LOG_NNDEBUG 0
 #define LOG_TAG "EmulatedCamera_FakeCamera3"
+#include <cutils/properties.h>
 #include <utils/Log.h>
 
 #include "EmulatedFakeCamera3.h"
@@ -64,44 +65,6 @@ const int32_t EmulatedFakeCamera3::kAvailableFormats[5] = {
         HAL_PIXEL_FORMAT_YCbCr_420_888
 };
 
-const uint32_t EmulatedFakeCamera3::kAvailableRawSizes[2] = {
-    640, 480
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t EmulatedFakeCamera3::kAvailableRawMinDurations[1] = {
-    (const uint64_t)Sensor::kFrameDurationRange[0]
-};
-
-const uint32_t EmulatedFakeCamera3::kAvailableProcessedSizesBack[4] = {
-    640, 480, 320, 240
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint32_t EmulatedFakeCamera3::kAvailableProcessedSizesFront[4] = {
-    320, 240, 160, 120
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t EmulatedFakeCamera3::kAvailableProcessedMinDurations[1] = {
-    (const uint64_t)Sensor::kFrameDurationRange[0]
-};
-
-const uint32_t EmulatedFakeCamera3::kAvailableJpegSizesBack[2] = {
-    640, 480
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint32_t EmulatedFakeCamera3::kAvailableJpegSizesFront[2] = {
-    320, 240
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-
-const uint64_t EmulatedFakeCamera3::kAvailableJpegMinDurations[1] = {
-    (const uint64_t)Sensor::kFrameDurationRange[0]
-};
-
 /**
  * 3A constants
  */
@@ -125,18 +88,13 @@ EmulatedFakeCamera3::EmulatedFakeCamera3(int cameraId, bool facingBack,
         struct hw_module_t* module) :
         EmulatedCamera3(cameraId, module),
         mFacingBack(facingBack) {
-    ALOGI("Constructing emulated fake camera 3 facing %s",
-            facingBack ? "back" : "front");
+    ALOGI("Constructing emulated fake camera 3: ID %d, facing %s",
+            mCameraID, facingBack ? "back" : "front");
 
     for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) {
         mDefaultTemplates[i] = NULL;
     }
 
-    /**
-     * Front cameras = limited mode
-     * Back cameras = full mode
-     */
-    mFullMode = facingBack;
 }
 
 EmulatedFakeCamera3::~EmulatedFakeCamera3() {
@@ -156,6 +114,13 @@ status_t EmulatedFakeCamera3::Initialize() {
         return INVALID_OPERATION;
     }
 
+    res = getCameraCapabilities();
+    if (res != OK) {
+        ALOGE("%s: Unable to get camera capabilities: %s (%d)",
+                __FUNCTION__, strerror(-res), res);
+        return res;
+    }
+
     res = constructStaticInfo();
     if (res != OK) {
         ALOGE("%s: Unable to allocate static info: %s (%d)",
@@ -198,8 +163,6 @@ status_t EmulatedFakeCamera3::connectCamera(hw_device_t** device) {
     mAeState      = ANDROID_CONTROL_AE_STATE_INACTIVE;
     mAfState      = ANDROID_CONTROL_AF_STATE_INACTIVE;
     mAwbState     = ANDROID_CONTROL_AWB_STATE_INACTIVE;
-    mAfTriggerId  = 0;
-    mAeTriggerId  = 0;
     mAeCurrentExposureTime = kNormalExposureTime;
     mAeCurrentSensitivity  = kNormalSensitivity;
 
@@ -341,20 +304,7 @@ status_t EmulatedFakeCamera3::configureStreams(
             // New stream, construct info
             PrivateStreamInfo *privStream = new PrivateStreamInfo();
             privStream->alive = true;
-            privStream->registered = false;
 
-            switch (newStream->stream_type) {
-                case CAMERA3_STREAM_OUTPUT:
-                    newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE;
-                    break;
-                case CAMERA3_STREAM_INPUT:
-                    newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ;
-                    break;
-                case CAMERA3_STREAM_BIDIRECTIONAL:
-                    newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ |
-                            GRALLOC_USAGE_HW_CAMERA_WRITE;
-                    break;
-            }
             newStream->max_buffers = kMaxBufferCount;
             newStream->priv = privStream;
             mStreams.push_back(newStream);
@@ -364,6 +314,20 @@ status_t EmulatedFakeCamera3::configureStreams(
                     static_cast<PrivateStreamInfo*>(newStream->priv);
             privStream->alive = true;
         }
+        // Always update usage and max buffers
+        newStream->max_buffers = kMaxBufferCount;
+        switch (newStream->stream_type) {
+            case CAMERA3_STREAM_OUTPUT:
+                newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE;
+                break;
+            case CAMERA3_STREAM_INPUT:
+                newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ;
+                break;
+            case CAMERA3_STREAM_BIDIRECTIONAL:
+                newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ |
+                        GRALLOC_USAGE_HW_CAMERA_WRITE;
+                break;
+        }
     }
 
     /**
@@ -394,49 +358,11 @@ status_t EmulatedFakeCamera3::registerStreamBuffers(
     ALOGV("%s: E", __FUNCTION__);
     Mutex::Autolock l(mLock);
 
-    /**
-     * Sanity checks
-     */
-
-    // OK: register streams at any time during configure
-    // (but only once per stream)
-    if (mStatus != STATUS_READY && mStatus != STATUS_ACTIVE) {
-        ALOGE("%s: Cannot register buffers in state %d",
-                __FUNCTION__, mStatus);
-        return NO_INIT;
-    }
-
-    if (bufferSet == NULL) {
-        ALOGE("%s: NULL buffer set!", __FUNCTION__);
-        return BAD_VALUE;
-    }
-
-    StreamIterator s = mStreams.begin();
-    for (; s != mStreams.end(); ++s) {
-        if (bufferSet->stream == *s) break;
-    }
-    if (s == mStreams.end()) {
-        ALOGE("%s: Trying to register buffers for a non-configured stream!",
-                __FUNCTION__);
-        return BAD_VALUE;
-    }
+    // Should not be called in HAL versions >= 3.2
 
-    /**
-     * Register the buffers. This doesn't mean anything to the emulator besides
-     * marking them off as registered.
-     */
-
-    PrivateStreamInfo *privStream =
-            static_cast<PrivateStreamInfo*>((*s)->priv);
-
-    if (privStream->registered) {
-        ALOGE("%s: Illegal to register buffer more than once", __FUNCTION__);
-        return BAD_VALUE;
-    }
-
-    privStream->registered = true;
-
-    return OK;
+    ALOGE("%s: Should not be invoked on new HALs!",
+            __FUNCTION__);
+    return NO_INIT;
 }
 
 const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
@@ -444,7 +370,7 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
     ALOGV("%s: E", __FUNCTION__);
     Mutex::Autolock l(mLock);
 
-    if (type < 0 || type >= CAMERA2_TEMPLATE_COUNT) {
+    if (type < 0 || type >= CAMERA3_TEMPLATE_COUNT) {
         ALOGE("%s: Unknown request settings template: %d",
                 __FUNCTION__, type);
         return NULL;
@@ -528,11 +454,11 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
     uint8_t tonemapMode = 0;
     uint8_t edgeMode = 0;
     switch (type) {
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
+      case CAMERA3_TEMPLATE_STILL_CAPTURE:
         // fall-through
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
+      case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
         // fall-through
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
+      case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
         hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
         demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;
         noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
@@ -541,9 +467,9 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
         tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
         edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY;
         break;
-      case CAMERA2_TEMPLATE_PREVIEW:
+      case CAMERA3_TEMPLATE_PREVIEW:
         // fall-through
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
+      case CAMERA3_TEMPLATE_VIDEO_RECORD:
         // fall-through
       default:
         hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
@@ -564,18 +490,26 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
     settings.update(ANDROID_EDGE_MODE, &edgeMode, 1);
 
     /** android.noise */
+
     static const uint8_t noiseStrength = 5;
     settings.update(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1);
 
-    /** android.color */
-    static const float colorTransform[9] = {
-        1.0f, 0.f, 0.f,
-        0.f, 1.f, 0.f,
-        0.f, 0.f, 1.f
+    /** android.colorCorrection */
+
+    static const camera_metadata_rational colorTransform[9] = {
+        {1,1}, {0,1}, {0,1},
+        {0,1}, {1,1}, {0,1},
+        {0,1}, {0,1}, {1,1}
     };
     settings.update(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9);
 
+    static const float colorGains[4] = {
+        1.0f, 1.0f, 1.0f, 1.0f
+    };
+    settings.update(ANDROID_COLOR_CORRECTION_GAINS, colorGains, 4);
+
     /** android.tonemap */
+
     static const float tonemapCurve[4] = {
         0.f, 0.f,
         1.f, 1.f
@@ -589,10 +523,10 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
     settings.update(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
 
     /** android.scaler */
-    static const int32_t cropRegion[3] = {
-        0, 0, (int32_t)Sensor::kResolution[0]
+    static const int32_t cropRegion[4] = {
+        0, 0, (int32_t)Sensor::kResolution[0], (int32_t)Sensor::kResolution[1]
     };
-    settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
+    settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 4);
 
     /** android.jpeg */
     static const uint8_t jpegQuality = 80;
@@ -626,12 +560,9 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
         ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
     settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
 
-    static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
-    settings.update(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
-
-    static const uint8_t sharpnessMapMode =
-        ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF;
-    settings.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
+    static const uint8_t hotPixelMapMode =
+        ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
+    settings.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1);
 
     // faceRectangles, faceScores, faceLandmarks, faceIds, histogram,
     // sharpnessMap only in frames
@@ -640,28 +571,33 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
 
     uint8_t controlIntent = 0;
     switch (type) {
-      case CAMERA2_TEMPLATE_PREVIEW:
+      case CAMERA3_TEMPLATE_PREVIEW:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
         break;
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
+      case CAMERA3_TEMPLATE_STILL_CAPTURE:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
         break;
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
+      case CAMERA3_TEMPLATE_VIDEO_RECORD:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
         break;
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
+      case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
         break;
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
+      case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
         break;
+      case CAMERA3_TEMPLATE_MANUAL:
+        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
+        break;
       default:
         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
         break;
     }
     settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
 
-    static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
+    const uint8_t controlMode = (type == CAMERA3_TEMPLATE_MANUAL) ?
+            ANDROID_CONTROL_MODE_OFF :
+            ANDROID_CONTROL_MODE_AUTO;
     settings.update(ANDROID_CONTROL_MODE, &controlMode, 1);
 
     static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
@@ -670,56 +606,65 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
     static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
     settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
 
-    static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
+    const uint8_t aeMode = (type == CAMERA3_TEMPLATE_MANUAL) ?
+            ANDROID_CONTROL_AE_MODE_OFF :
+            ANDROID_CONTROL_AE_MODE_ON;
     settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
 
     static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
     settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
 
     static const int32_t controlRegions[5] = {
-        0, 0, (int32_t)Sensor::kResolution[0], (int32_t)Sensor::kResolution[1],
-        1000
+        0, 0, 0, 0, 0
     };
     settings.update(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
 
     static const int32_t aeExpCompensation = 0;
     settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1);
 
-    static const int32_t aeTargetFpsRange[2] = {
-        10, 30
+    int32_t aeTargetFpsRange[2] = {
+        5, 30
     };
+    if (type == CAMERA3_TEMPLATE_VIDEO_RECORD || type == CAMERA3_TEMPLATE_VIDEO_SNAPSHOT) {
+        aeTargetFpsRange[0] = 30;
+    }
     settings.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
 
     static const uint8_t aeAntibandingMode =
             ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
     settings.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
 
-    static const uint8_t awbMode =
+    static const uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
+    settings.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &aePrecaptureTrigger, 1);
+
+    const uint8_t awbMode = (type == CAMERA3_TEMPLATE_MANUAL) ?
+            ANDROID_CONTROL_AWB_MODE_OFF :
             ANDROID_CONTROL_AWB_MODE_AUTO;
     settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
 
     static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
     settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1);
 
-    settings.update(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
-
     uint8_t afMode = 0;
     switch (type) {
-      case CAMERA2_TEMPLATE_PREVIEW:
-        afMode = ANDROID_CONTROL_AF_MODE_AUTO;
+      case CAMERA3_TEMPLATE_PREVIEW:
+        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
         break;
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
-        afMode = ANDROID_CONTROL_AF_MODE_AUTO;
+      case CAMERA3_TEMPLATE_STILL_CAPTURE:
+        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
         break;
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
+      case CAMERA3_TEMPLATE_VIDEO_RECORD:
         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
         break;
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
+      case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
         break;
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
+      case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
         break;
+      case CAMERA3_TEMPLATE_MANUAL:
+        afMode = ANDROID_CONTROL_AF_MODE_OFF;
+        break;
       default:
         afMode = ANDROID_CONTROL_AF_MODE_AUTO;
         break;
@@ -728,11 +673,24 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings(
 
     settings.update(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
 
+    static const uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
+    settings.update(ANDROID_CONTROL_AF_TRIGGER, &afTrigger, 1);
+
     static const uint8_t vstabMode =
         ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
     settings.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
 
-    // aeState, awbState, afState only in frame
+    static const uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF;
+    settings.update(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1);
+
+    static const uint8_t lensShadingMapMode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
+    settings.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &lensShadingMapMode, 1);
+
+    static const uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
+    settings.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, &aberrationMode, 1);
+
+    static const int32_t testPatternMode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
+    settings.update(ANDROID_SENSOR_TEST_PATTERN_MODE, &testPatternMode, 1);
 
     mDefaultTemplates[type] = settings.release();
 
@@ -805,8 +763,8 @@ status_t EmulatedFakeCamera3::processCaptureRequest(
                     __FUNCTION__, frameNumber, idx);
             return BAD_VALUE;
         }
-        if (!priv->alive || !priv->registered) {
-            ALOGE("%s: Request %d: Buffer %zu: Unregistered or dead stream!",
+        if (!priv->alive) {
+            ALOGE("%s: Request %d: Buffer %zu: Dead stream!",
                     __FUNCTION__, frameNumber, idx);
             return BAD_VALUE;
         }
@@ -865,6 +823,11 @@ status_t EmulatedFakeCamera3::processCaptureRequest(
     frameDuration = settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0];
     sensitivity = settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
 
+    if (exposureTime > frameDuration) {
+        frameDuration = exposureTime + Sensor::kMinVerticalBlank;
+        settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
+    }
+
     Buffers *sensorBuffers = new Buffers();
     HalBufferVector *buffers = new HalBufferVector();
 
@@ -1004,163 +967,287 @@ status_t EmulatedFakeCamera3::processCaptureRequest(
     return OK;
 }
 
+status_t EmulatedFakeCamera3::flush() {
+    ALOGW("%s: Not implemented; ignored", __FUNCTION__);
+    return OK;
+}
+
 /** Debug methods */
 
 void EmulatedFakeCamera3::dump(int fd) {
 
 }
 
-/** Tag query methods */
-const char* EmulatedFakeCamera3::getVendorSectionName(uint32_t tag) {
-    return NULL;
-}
+/**
+ * Private methods
+ */
 
-const char* EmulatedFakeCamera3::getVendorTagName(uint32_t tag) {
-    return NULL;
-}
+status_t EmulatedFakeCamera3::getCameraCapabilities() {
 
-int EmulatedFakeCamera3::getVendorTagType(uint32_t tag) {
-    return 0;
+    const char *key = mFacingBack ? "qemu.sf.back_camera_caps" : "qemu.sf.front_camera_caps";
+
+    /* Defined by 'qemu.sf.*_camera_caps' boot property: if the
+     * property doesn't exist, it is assumed to list FULL. */
+    char prop[PROPERTY_VALUE_MAX];
+    if (property_get(key, prop, NULL) > 0) {
+        char **saveptr = nullptr;
+        char *cap = strtok_r(prop, " ,", saveptr);
+        while (cap != NULL) {
+            for (int i = 0; i < NUM_CAPABILITIES; i++) {
+                if (!strcasecmp(cap, sAvailableCapabilitiesStrings[i])) {
+                    mCapabilities.add(static_cast<AvailableCapabilities>(i));
+                    break;
+                }
+            }
+            cap = strtok_r(NULL, " ,", saveptr);
+        }
+        if (mCapabilities.size() == 0) {
+            ALOGE("qemu.sf.back_camera_caps had no valid capabilities: %s", prop);
+        }
+    }
+    // Default to FULL_LEVEL if nothing is defined
+    if (mCapabilities.size() == 0) {
+        mCapabilities.add(FULL_LEVEL);
+    }
+
+    // Add level-based caps
+    if (hasCapability(FULL_LEVEL)) {
+        mCapabilities.add(BACKWARD_COMPATIBLE);
+        mCapabilities.add(BURST_CAPTURE);
+        mCapabilities.add(READ_SENSOR_SETTINGS);
+        mCapabilities.add(MANUAL_SENSOR);
+        mCapabilities.add(MANUAL_POST_PROCESSING);
+    };
+
+    ALOGI("Camera %d capabilities:", mCameraID);
+    for (size_t i = 0; i < mCapabilities.size(); i++) {
+        ALOGI("  %s", sAvailableCapabilitiesStrings[mCapabilities[i]]);
+    }
+
+    return OK;
 }
 
-/**
- * Private methods
- */
+bool EmulatedFakeCamera3::hasCapability(AvailableCapabilities cap) {
+    ssize_t idx = mCapabilities.indexOf(cap);
+    return idx >= 0;
+}
 
 status_t EmulatedFakeCamera3::constructStaticInfo() {
 
     CameraMetadata info;
+    Vector<int32_t> availableCharacteristicsKeys;
+    status_t res;
+
+#define ADD_STATIC_ENTRY(name, varptr, count) \
+        availableCharacteristicsKeys.add(name);   \
+        res = info.update(name, varptr, count); \
+        if (res != OK) return res
+
     // android.lens
 
     // 5 cm min focus distance for back camera, infinity (fixed focus) for front
     const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0;
-    info.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
             &minFocusDistance, 1);
 
     // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front
     const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0;
-    info.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
             &minFocusDistance, 1);
 
     static const float focalLength = 3.30f; // mm
-    info.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
             &focalLength, 1);
     static const float aperture = 2.8f;
-    info.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
             &aperture, 1);
     static const float filterDensity = 0;
-    info.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
             &filterDensity, 1);
     static const uint8_t availableOpticalStabilization =
             ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
-    info.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
             &availableOpticalStabilization, 1);
 
     static const int32_t lensShadingMapSize[] = {1, 1};
-    info.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize,
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize,
             sizeof(lensShadingMapSize)/sizeof(int32_t));
 
-    uint8_t lensFacing = mFacingBack ?
+    static const uint8_t lensFacing = mFacingBack ?
             ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
-    info.update(ANDROID_LENS_FACING, &lensFacing, 1);
+    ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &lensFacing, 1);
+
+    static const uint8_t lensFocusCalibration =
+            ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;
+    ADD_STATIC_ENTRY(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, &lensFocusCalibration, 1);
 
     // android.sensor
 
-    info.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
             Sensor::kExposureTimeRange, 2);
 
-    info.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
             &Sensor::kFrameDurationRange[1], 1);
 
-    info.update(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
             Sensor::kSensitivityRange,
             sizeof(Sensor::kSensitivityRange)
             /sizeof(int32_t));
 
-    info.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
+            &Sensor::kSensitivityRange[1], 1);
+
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
             &Sensor::kColorFilterArrangement, 1);
 
     static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm
-    info.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
             sensorPhysicalSize, 2);
 
-    info.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
             (int32_t*)Sensor::kResolution, 2);
 
-    info.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
-            (int32_t*)Sensor::kResolution, 2);
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
+            (int32_t*)Sensor::kActiveArray, 4);
 
-    info.update(ANDROID_SENSOR_INFO_WHITE_LEVEL,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_WHITE_LEVEL,
             (int32_t*)&Sensor::kMaxRawValue, 1);
 
     static const int32_t blackLevelPattern[4] = {
             (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel,
             (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel
     };
-    info.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
             blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
 
-    static const int32_t orientation = 0; // unrotated (0 degrees)
-    info.update(ANDROID_SENSOR_ORIENTATION, &orientation, 1);
+    static const int32_t orientation = 90; // Aligned with 'long edge'
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_ORIENTATION, &orientation, 1);
 
-    //TODO: sensor color calibration fields
+    static const int32_t availableTestPatternModes[] = {
+            ANDROID_SENSOR_TEST_PATTERN_MODE_OFF
+    };
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
+            availableTestPatternModes, sizeof(availableTestPatternModes)/sizeof(int32_t));
+
+    static const uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME;
+    ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, &timestampSource, 1);
 
     // android.flash
+
     static const uint8_t flashAvailable = 0;
-    info.update(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
+    ADD_STATIC_ENTRY(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
 
     static const int64_t flashChargeDuration = 0;
-    info.update(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
+    ADD_STATIC_ENTRY(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
 
     // android.tonemap
 
     static const int32_t tonemapCurvePoints = 128;
-    info.update(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
-
-    // android.scaler
-
-    info.update(ANDROID_SCALER_AVAILABLE_FORMATS,
-            kAvailableFormats,
-            sizeof(kAvailableFormats)/sizeof(int32_t));
+    ADD_STATIC_ENTRY(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
 
-    info.update(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
-            (int32_t*)kAvailableRawSizes,
-            sizeof(kAvailableRawSizes)/sizeof(uint32_t));
+    static const uint8_t availableToneMapModes[] = {
+            ANDROID_TONEMAP_MODE_CONTRAST_CURVE,  ANDROID_TONEMAP_MODE_FAST,
+            ANDROID_TONEMAP_MODE_HIGH_QUALITY
+    };
+    ADD_STATIC_ENTRY(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, availableToneMapModes,
+            sizeof(availableToneMapModes));
 
-    info.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
-            (int64_t*)kAvailableRawMinDurations,
-            sizeof(kAvailableRawMinDurations)/sizeof(uint64_t));
+    // android.scaler
 
     if (mFacingBack) {
-        info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
-                (int32_t*)kAvailableProcessedSizesBack,
-                sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t));
-    } else {
-        info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
-                (int32_t*)kAvailableProcessedSizesFront,
-                sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t));
-    }
-
-    info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
-            (int64_t*)kAvailableProcessedMinDurations,
-            sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t));
 
-    if (mFacingBack) {
-        info.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
-                (int32_t*)kAvailableJpegSizesBack,
-                sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t));
+        const int32_t availableStreamConfigurationsBack[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
+                availableStreamConfigurationsBack,
+                sizeof(availableStreamConfigurationsBack)/sizeof(int32_t));
+
+        const int64_t availableMinFrameDurationsBack[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0]
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
+                availableMinFrameDurationsBack,
+                sizeof(availableMinFrameDurationsBack)/sizeof(int64_t));
+
+        const int64_t availableStallDurationsBack[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, 0,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, 0,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, 0,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, 0,
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, 0,
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, 0,
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0]
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
+                availableStallDurationsBack,
+                sizeof(availableStallDurationsBack)/sizeof(int64_t));
     } else {
-        info.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
-                (int32_t*)kAvailableJpegSizesFront,
-                sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t));
-    }
 
-    info.update(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
-            (int64_t*)kAvailableJpegMinDurations,
-            sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t));
+        const int32_t availableStreamConfigurationsFront[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
+                availableStreamConfigurationsFront,
+                sizeof(availableStreamConfigurationsFront)/sizeof(int32_t));
+
+        const int64_t availableMinFrameDurationsFront[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0]
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
+                availableMinFrameDurationsFront,
+                sizeof(availableMinFrameDurationsFront)/sizeof(int64_t));
+
+        const int64_t availableStallDurationsFront[] = {
+            HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0],
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, 0,
+            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, 0,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, 0,
+            HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, 0,
+            HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, 0,
+            HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, 0,
+            HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0]
+        };
+        ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
+                availableStallDurationsFront,
+                sizeof(availableStallDurationsFront)/sizeof(int64_t));
+    }
+
+    static const uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_FREEFORM;
+    ADD_STATIC_ENTRY(ANDROID_SCALER_CROPPING_TYPE,
+            &croppingType, 1);
 
     static const float maxZoom = 10;
-    info.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
+    ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
             &maxZoom, 1);
 
     // android.jpeg
@@ -1170,11 +1257,11 @@ status_t EmulatedFakeCamera3::constructStaticInfo() {
             160, 120,
             320, 240
      };
-    info.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
+    ADD_STATIC_ENTRY(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
             jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
 
     static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize;
-    info.update(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
+    ADD_STATIC_ENTRY(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
 
     // android.stats
 
@@ -1183,71 +1270,87 @@ status_t EmulatedFakeCamera3::constructStaticInfo() {
         ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE,
         ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
     };
-
-    info.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
             availableFaceDetectModes,
             sizeof(availableFaceDetectModes));
 
     static const int32_t maxFaceCount = 8;
-    info.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
             &maxFaceCount, 1);
 
     static const int32_t histogramSize = 64;
-    info.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
             &histogramSize, 1);
 
     static const int32_t maxHistogramCount = 1000;
-    info.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
             &maxHistogramCount, 1);
 
     static const int32_t sharpnessMapSize[2] = {64, 64};
-    info.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
             sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
 
     static const int32_t maxSharpnessMapValue = 1000;
-    info.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
             &maxSharpnessMapValue, 1);
 
+    static const uint8_t availableShadingMapModes[] = {
+            ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF
+    };
+    ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
+            availableShadingMapModes, sizeof(availableShadingMapModes));
+
+    // android.sync
+
+    static const int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;
+    ADD_STATIC_ENTRY(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1);
+
     // android.control
 
+    static const uint8_t availableControlModes[] = {
+            ANDROID_CONTROL_MODE_OFF, ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE
+    };
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES,
+            availableControlModes, sizeof(availableControlModes));
+
     static const uint8_t availableSceneModes[] = {
-            ANDROID_CONTROL_SCENE_MODE_DISABLED
+            ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY
     };
-    info.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
             availableSceneModes, sizeof(availableSceneModes));
 
     static const uint8_t availableEffects[] = {
             ANDROID_CONTROL_EFFECT_MODE_OFF
     };
-    info.update(ANDROID_CONTROL_AVAILABLE_EFFECTS,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_EFFECTS,
             availableEffects, sizeof(availableEffects));
 
-    static const int32_t max3aRegions[] = {/*AE*/ 0,/*AWB*/ 0,/*AF*/ 0};
-    info.update(ANDROID_CONTROL_MAX_REGIONS,
+    static const int32_t max3aRegions[] = {/*AE*/ 1,/*AWB*/ 0,/*AF*/ 1};
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_MAX_REGIONS,
             max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0]));
 
     static const uint8_t availableAeModes[] = {
             ANDROID_CONTROL_AE_MODE_OFF,
             ANDROID_CONTROL_AE_MODE_ON
     };
-    info.update(ANDROID_CONTROL_AE_AVAILABLE_MODES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_MODES,
             availableAeModes, sizeof(availableAeModes));
 
     static const camera_metadata_rational exposureCompensationStep = {
             1, 3
     };
-    info.update(ANDROID_CONTROL_AE_COMPENSATION_STEP,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP,
             &exposureCompensationStep, 1);
 
     int32_t exposureCompensationRange[] = {-9, 9};
-    info.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
             exposureCompensationRange,
             sizeof(exposureCompensationRange)/sizeof(int32_t));
 
     static const int32_t availableTargetFpsRanges[] = {
-            5, 30, 15, 30
+            5, 30, 15, 30, 15, 15, 30, 30
     };
-    info.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
             availableTargetFpsRanges,
             sizeof(availableTargetFpsRanges)/sizeof(int32_t));
 
@@ -1255,9 +1358,13 @@ status_t EmulatedFakeCamera3::constructStaticInfo() {
             ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
             ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
     };
-    info.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
             availableAntibandingModes, sizeof(availableAntibandingModes));
 
+    static const uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
+            &aeLockAvailable, 1);
+
     static const uint8_t availableAwbModes[] = {
             ANDROID_CONTROL_AWB_MODE_OFF,
             ANDROID_CONTROL_AWB_MODE_AUTO,
@@ -1266,9 +1373,13 @@ status_t EmulatedFakeCamera3::constructStaticInfo() {
             ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
             ANDROID_CONTROL_AWB_MODE_SHADE
     };
-    info.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
             availableAwbModes, sizeof(availableAwbModes));
 
+    static const uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
+            &awbLockAvailable, 1);
+
     static const uint8_t availableAfModesBack[] = {
             ANDROID_CONTROL_AF_MODE_OFF,
             ANDROID_CONTROL_AF_MODE_AUTO,
@@ -1282,29 +1393,156 @@ status_t EmulatedFakeCamera3::constructStaticInfo() {
     };
 
     if (mFacingBack) {
-        info.update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
+        ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES,
                     availableAfModesBack, sizeof(availableAfModesBack));
     } else {
-        info.update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
+        ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES,
                     availableAfModesFront, sizeof(availableAfModesFront));
     }
 
     static const uint8_t availableVstabModes[] = {
             ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF
     };
-    info.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
+    ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
             availableVstabModes, sizeof(availableVstabModes));
 
+    // android.colorCorrection
+
+    static const uint8_t availableAberrationModes[] = {
+            ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF,
+            ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST,
+            ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY
+    };
+    ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
+            availableAberrationModes, sizeof(availableAberrationModes));
+
+    // android.edge
+
+    static const uint8_t availableEdgeModes[] = {
+            ANDROID_EDGE_MODE_OFF, ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY
+    };
+    ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
+            availableEdgeModes, sizeof(availableEdgeModes));
+
     // android.info
-    const uint8_t supportedHardwareLevel =
-        mFullMode ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL :
+
+    static const uint8_t supportedHardwareLevel =
+            hasCapability(FULL_LEVEL) ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL :
                     ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
-    info.update(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
+    ADD_STATIC_ENTRY(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
                 &supportedHardwareLevel,
                 /*count*/1);
 
+    // android.noiseReduction
+
+    static const uint8_t availableNoiseReductionModes[] = {
+            ANDROID_NOISE_REDUCTION_MODE_OFF,
+            ANDROID_NOISE_REDUCTION_MODE_FAST,
+            ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY
+    };
+    ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
+            availableNoiseReductionModes, sizeof(availableNoiseReductionModes));
+
+    // android.shading
+
+    static const uint8_t availableShadingModes[] = {
+            ANDROID_SHADING_MODE_OFF, ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY
+    };
+    ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes,
+            sizeof(availableShadingModes));
+
+    // android.request
+
+    static const int32_t maxNumOutputStreams[] = {
+            kMaxRawStreamCount, kMaxProcessedStreamCount, kMaxJpegStreamCount
+    };
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, maxNumOutputStreams, 3);
+
+    static const uint8_t maxPipelineDepth = kMaxBufferCount;
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &maxPipelineDepth, 1);
+
+    static const int32_t partialResultCount = 1;
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
+            &partialResultCount, /*count*/1);
+
+    SortedVector<uint8_t> caps;
+    for (size_t i = 0; i < mCapabilities.size(); i++) {
+        switch(mCapabilities[i]) {
+            case BACKWARD_COMPATIBLE:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
+                break;
+            case MANUAL_SENSOR:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR);
+                break;
+            case MANUAL_POST_PROCESSING:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING);
+                break;
+            case RAW:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW);
+                break;
+            case PRIVATE_REPROCESSING:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING);
+                break;
+            case READ_SENSOR_SETTINGS:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS);
+                break;
+            case BURST_CAPTURE:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE);
+                break;
+            case YUV_REPROCESSING:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING);
+                break;
+            case DEPTH_OUTPUT:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT);
+                break;
+            case CONSTRAINED_HIGH_SPEED_VIDEO:
+                caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO);
+                break;
+            default:
+                // Ignore LEVELs
+                break;
+        }
+    }
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, caps.array(), caps.size());
+
+    // Scan a default request template for included request keys
+    Vector<int32_t> availableRequestKeys;
+    const camera_metadata_t *previewRequest =
+        constructDefaultRequestSettings(CAMERA3_TEMPLATE_PREVIEW);
+    for (size_t i = 0; i < get_camera_metadata_entry_count(previewRequest); i++) {
+        camera_metadata_ro_entry_t entry;
+        get_camera_metadata_ro_entry(previewRequest, i, &entry);
+        availableRequestKeys.add(entry.tag);
+    }
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, availableRequestKeys.array(),
+            availableRequestKeys.size());
+
+    // Add a few more result keys. Must be kept up to date with the various places that add these
+
+    Vector<int32_t> availableResultKeys(availableRequestKeys);
+    availableResultKeys.add(ANDROID_CONTROL_AE_STATE);
+    availableResultKeys.add(ANDROID_CONTROL_AF_STATE);
+    availableResultKeys.add(ANDROID_CONTROL_AWB_STATE);
+    availableResultKeys.add(ANDROID_FLASH_STATE);
+    availableResultKeys.add(ANDROID_LENS_STATE);
+    availableResultKeys.add(ANDROID_LENS_FOCUS_RANGE);
+    availableResultKeys.add(ANDROID_REQUEST_PIPELINE_DEPTH);
+    availableResultKeys.add(ANDROID_SENSOR_TIMESTAMP);
+    availableResultKeys.add(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW);
+    availableResultKeys.add(ANDROID_STATISTICS_SCENE_FLICKER);
+
+    ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, availableResultKeys.array(),
+            availableResultKeys.size());
+
+    // Needs to be last, to collect all the keys set
+
+    availableCharacteristicsKeys.add(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+    info.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
+            availableCharacteristicsKeys);
+
     mCameraInfo = info.release();
 
+#undef ADD_STATIC_ENTRY
     return OK;
 }
 
@@ -1387,9 +1625,10 @@ status_t EmulatedFakeCamera3::doFakeAE(CameraMetadata &settings) {
             // OK for AUTO modes
             break;
         default:
-            ALOGE("%s: Emulator doesn't support AE mode %d",
+            // Mostly silently ignore unsupported modes
+            ALOGV("%s: Emulator doesn't support AE mode %d, assuming ON",
                     __FUNCTION__, aeMode);
-            return BAD_VALUE;
+            break;
     }
 
     e = settings.find(ANDROID_CONTROL_AE_LOCK);
@@ -1414,20 +1653,6 @@ status_t EmulatedFakeCamera3::doFakeAE(CameraMetadata &settings) {
               e.count);
     }
 
-    // If we have an aePrecaptureTrigger, aePrecaptureId should be set too
-    if (e.count != 0) {
-        e = settings.find(ANDROID_CONTROL_AE_PRECAPTURE_ID);
-
-        if (e.count == 0) {
-            ALOGE("%s: When android.control.aePrecaptureTrigger is set "
-                  " in the request, aePrecaptureId needs to be set as well",
-                  __FUNCTION__);
-            return BAD_VALUE;
-        }
-
-        mAeTriggerId = e.data.i32[0];
-    }
-
     if (precaptureTrigger || mAeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
         // Run precapture sequence
         if (mAeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
@@ -1514,23 +1739,10 @@ status_t EmulatedFakeCamera3::doFakeAF(CameraMetadata &settings) {
     e = settings.find(ANDROID_CONTROL_AF_TRIGGER);
     typedef camera_metadata_enum_android_control_af_trigger af_trigger_t;
     af_trigger_t afTrigger;
-    // If we have an afTrigger, afTriggerId should be set too
     if (e.count != 0) {
         afTrigger = static_cast<af_trigger_t>(e.data.u8[0]);
 
-        e = settings.find(ANDROID_CONTROL_AF_TRIGGER_ID);
-
-        if (e.count == 0) {
-            ALOGE("%s: When android.control.afTrigger is set "
-                  " in the request, afTriggerId needs to be set as well",
-                  __FUNCTION__);
-            return BAD_VALUE;
-        }
-
-        mAfTriggerId = e.data.i32[0];
-
         ALOGV("%s: AF trigger set to 0x%x", __FUNCTION__, afTrigger);
-        ALOGV("%s: AF trigger ID set to 0x%x", __FUNCTION__, mAfTriggerId);
         ALOGV("%s: AF mode is 0x%x", __FUNCTION__, afMode);
     } else {
         afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
@@ -1770,13 +1982,24 @@ void EmulatedFakeCamera3::update3A(CameraMetadata &settings) {
             &mAfState, 1);
     settings.update(ANDROID_CONTROL_AWB_STATE,
             &mAwbState, 1);
-    /**
-     * TODO: Trigger IDs need a think-through
-     */
-    settings.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
-            &mAeTriggerId, 1);
-    settings.update(ANDROID_CONTROL_AF_TRIGGER_ID,
-            &mAfTriggerId, 1);
+
+    uint8_t lensState;
+    switch (mAfState) {
+        case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
+        case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
+            lensState = ANDROID_LENS_STATE_MOVING;
+            break;
+        case ANDROID_CONTROL_AF_STATE_INACTIVE:
+        case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
+        case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
+        case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
+        case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
+        default:
+            lensState = ANDROID_LENS_STATE_STATIONARY;
+            break;
+    }
+    settings.update(ANDROID_LENS_STATE, &lensState, 1);
+
 }
 
 void EmulatedFakeCamera3::signalReadoutIdle() {
@@ -1954,13 +2177,36 @@ bool EmulatedFakeCamera3::ReadoutThread::threadLoop() {
 
     camera3_capture_result result;
 
+    static const uint8_t sceneFlicker = ANDROID_STATISTICS_SCENE_FLICKER_NONE;
+    mCurrentRequest.settings.update(ANDROID_STATISTICS_SCENE_FLICKER,
+            &sceneFlicker, 1);
+
+    static const uint8_t flashState = ANDROID_FLASH_STATE_UNAVAILABLE;
+    mCurrentRequest.settings.update(ANDROID_FLASH_STATE,
+            &flashState, 1);
+
     mCurrentRequest.settings.update(ANDROID_SENSOR_TIMESTAMP,
             &captureTime, 1);
 
+    nsecs_t rollingShutterSkew = Sensor::kFrameDurationRange[0];
+    mCurrentRequest.settings.update(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
+            &rollingShutterSkew, 1);
+
+    float focusRange[] = { 1.0f/5.0f, 0 }; // 5 m to infinity in focus
+    mCurrentRequest.settings.update(ANDROID_LENS_FOCUS_RANGE,
+            focusRange, sizeof(focusRange)/sizeof(float));
+
+    // JPEGs take a stage longer
+    const uint8_t pipelineDepth = needJpeg ? kMaxBufferCount : kMaxBufferCount - 1;
+    mCurrentRequest.settings.update(ANDROID_REQUEST_PIPELINE_DEPTH,
+            &pipelineDepth, 1);
+
     result.frame_number = mCurrentRequest.frameNumber;
     result.result = mCurrentRequest.settings.getAndLock();
     result.num_output_buffers = mCurrentRequest.buffers->size();
     result.output_buffers = mCurrentRequest.buffers->array();
+    result.input_buffer = nullptr;
+    result.partial_result = 1;
 
     // Go idle if queue is empty, before sending result
     bool signalIdle = false;
diff --git a/camera/EmulatedFakeCamera3.h b/camera/EmulatedFakeCamera3.h
index 0889813..4835009 100644
--- a/camera/EmulatedFakeCamera3.h
+++ b/camera/EmulatedFakeCamera3.h
@@ -28,6 +28,7 @@
 #include "fake-pipeline2/Sensor.h"
 #include "fake-pipeline2/JpegCompressor.h"
 #include <camera/CameraMetadata.h>
+#include <utils/SortedVector.h>
 #include <utils/List.h>
 #include <utils/Mutex.h>
 
@@ -87,18 +88,20 @@ protected:
 
     virtual status_t processCaptureRequest(camera3_capture_request *request);
 
+    virtual status_t flush();
+
     /** Debug methods */
 
     virtual void dump(int fd);
 
-    /** Tag query methods */
-    virtual const char *getVendorSectionName(uint32_t tag);
-
-    virtual const char *getVendorTagName(uint32_t tag);
+private:
 
-    virtual int getVendorTagType(uint32_t tag);
+    /**
+     * Get the requested capability set for this camera
+     */
+    status_t getCameraCapabilities();
 
-private:
+    bool hasCapability(AvailableCapabilities cap);
 
     /**
      * Build the static info metadata buffer for this device
@@ -136,14 +139,6 @@ private:
     // no concept of a stream id.
     static const uint32_t kGenericStreamId = 1;
     static const int32_t  kAvailableFormats[];
-    static const uint32_t kAvailableRawSizes[];
-    static const uint64_t kAvailableRawMinDurations[];
-    static const uint32_t kAvailableProcessedSizesBack[];
-    static const uint32_t kAvailableProcessedSizesFront[];
-    static const uint64_t kAvailableProcessedMinDurations[];
-    static const uint32_t kAvailableJpegSizesBack[];
-    static const uint32_t kAvailableJpegSizesFront[];
-    static const uint64_t kAvailableJpegMinDurations[];
 
     static const int64_t  kSyncWaitTimeout     = 10000000; // 10 ms
     static const int32_t  kMaxSyncTimeoutCount = 1000; // 1000 kSyncWaitTimeouts
@@ -159,8 +154,7 @@ private:
     /* Facing back (true) or front (false) switch. */
     bool               mFacingBack;
 
-    /* Full mode (true) or limited mode (false) switch */
-    bool               mFullMode;
+    SortedVector<AvailableCapabilities> mCapabilities;
 
     /**
      * Cache for default templates. Once one is requested, the pointer must be
@@ -173,7 +167,6 @@ private:
      */
     struct PrivateStreamInfo {
         bool alive;
-        bool registered;
     };
 
     // Shortcut to the input stream
@@ -283,8 +276,6 @@ private:
     uint8_t mAeMode;
     uint8_t mAfMode;
     uint8_t mAwbMode;
-    int     mAfTriggerId;
-    int     mAeTriggerId;
 
     int     mAeCounter;
     nsecs_t mAeCurrentExposureTime;
diff --git a/camera/fake-pipeline2/Sensor.cpp b/camera/fake-pipeline2/Sensor.cpp
index 594a060..ac3961f 100644
--- a/camera/fake-pipeline2/Sensor.cpp
+++ b/camera/fake-pipeline2/Sensor.cpp
@@ -35,11 +35,17 @@
 namespace android {
 
 const unsigned int Sensor::kResolution[2]  = {640, 480};
+const unsigned int Sensor::kActiveArray[4]  = {0, 0, 640, 480};
 
+//const nsecs_t Sensor::kExposureTimeRange[2] =
+//    {1000L, 30000000000L} ; // 1 us - 30 sec
+//const nsecs_t Sensor::kFrameDurationRange[2] =
+//    {33331760L, 30000000000L}; // ~1/30 s - 30 sec
 const nsecs_t Sensor::kExposureTimeRange[2] =
-    {1000L, 30000000000L} ; // 1 us - 30 sec
+    {1000L, 300000000L} ; // 1 us - 0.3 sec
 const nsecs_t Sensor::kFrameDurationRange[2] =
-    {33331760L, 30000000000L}; // ~1/30 s - 30 sec
+    {33331760L, 300000000L}; // ~1/30 s - 0.3 sec
+
 const nsecs_t Sensor::kMinVerticalBlank = 10000L;
 
 const uint8_t Sensor::kColorFilterArrangement =
diff --git a/camera/fake-pipeline2/Sensor.h b/camera/fake-pipeline2/Sensor.h
index b485844..7cc7b4a 100644
--- a/camera/fake-pipeline2/Sensor.h
+++ b/camera/fake-pipeline2/Sensor.h
@@ -158,6 +158,7 @@ class Sensor: private Thread, public virtual RefBase {
      * Static sensor characteristics
      */
     static const unsigned int kResolution[2];
+    static const unsigned int kActiveArray[4];
 
     static const nsecs_t kExposureTimeRange[2];
     static const nsecs_t kFrameDurationRange[2];