Merge "Camera: Update emulator camera v3 HAL to v3.3, module to v2.3" into mnc-dev

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];