Merge tm-dev-plus-aosp-without-vendor@8763363temp_sam_242648940

Bug: 236760014
Merged-In: I19204b9f685c940887bdae9172eb892c69bf4441
Change-Id: Ibdfa9ba05da5701414ea99c4c3c47accb618fd96

90 files changed, 4142 insertions, 2405 deletions

diff --git a/common/apex_update_listener/apex_update_listener.cc b/common/apex_update_listener/apex_update_listener.cc
index 604f9d2..24f38bc 100644
--- a/common/apex_update_listener/apex_update_listener.cc
+++ b/common/apex_update_listener/apex_update_listener.cc
@@ -26,7 +26,7 @@ std::string ToString(const T& value) {
 ApexUpdateListener::ApexUpdateListener(
     ApexUpdateListener::Sigil, const std::string& apex_name,
     const std::string& apex_info_list_file_name, CallbackFunction callback,
-    int fd, int wd, std::set<Info> last_info)
+    int fd, int wd, const std::set<Info>& last_info)
     : apex_name_(apex_name),
       apex_info_list_file_name_(apex_info_list_file_name),
       callback_function_(callback),
diff --git a/common/apex_update_listener/apex_update_listener.h b/common/apex_update_listener/apex_update_listener.h
index 6263144..195d24c 100644
--- a/common/apex_update_listener/apex_update_listener.h
+++ b/common/apex_update_listener/apex_update_listener.h
@@ -66,7 +66,7 @@ class ApexUpdateListener {
   ApexUpdateListener(Sigil, const std::string& apex_name,
                      const std::string& apex_info_list_file_name,
                      CallbackFunction callback, int fd, int wd,
-                     std::set<Info> last_info);
+                     const std::set<Info>& last_info);
 
   static std::unique_ptr<ApexUpdateListener> Make(
       const std::string& apex_name, CallbackFunction callback,
diff --git a/common/hal/Android.bp b/common/hal/Android.bp
index 7726ddd..f953dc8 100644
--- a/common/hal/Android.bp
+++ b/common/hal/Android.bp
@@ -39,7 +39,7 @@ cc_defaults {
         "-Wextra"
     ],
     header_libs: [
-        "libgooglecamerahal_headers",
+        "//hardware/google/camera:libgooglecamerahal_headers",
         "libhardware_headers",
     ],
 }
diff --git a/common/hal/hidl_service/Android.bp b/common/hal/aidl_service/Android.bp
index 786e7a6..df5d70e 100644
--- a/common/hal/hidl_service/Android.bp
+++ b/common/hal/aidl_service/Android.bp
@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 
+//TODO: b/196432585
+//Change the service names to match AIDL instead of HIDL major, minor versioning. Currently
+//left alone to avoid accidentally breaking targets.
+
 package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
@@ -54,18 +58,18 @@ python_binary_host {
 }
 
 cc_genrule {
-   name: "hidl_camera_build_version",
+   name: "aidl_camera_build_version",
    tool_files: ["version_script.py"],
    cmd: "python3 $(location version_script.py) $(in) $(out)",
    vendor: true,
    srcs: [
-       "hidl_camera_build_version.inl",
+       "aidl_camera_build_version.inl",
    ],
-   out: ["hidl_camera_build_version.h"],
+   out: ["aidl_camera_build_version.h"],
 }
 
 cc_defaults {
-    name: "camera_service_defaults",
+    name: "camera_service_defaults_common",
     defaults: [
         "google_camera_hal_defaults",
         "apex_update_listener_cc_defaults_static",
@@ -73,35 +77,28 @@ cc_defaults {
     vendor: true,
     relative_install_path: "hw",
     srcs: [
-        "hidl_camera_device.cc",
-        "hidl_camera_device_session.cc",
-        "hidl_camera_provider.cc",
-        "hidl_profiler.cc",
+        "aidl_camera_device.cc",
+        "aidl_camera_device_session.cc",
+        "aidl_camera_provider.cc",
+        "aidl_profiler.cc",
         "hidl_thermal_utils.cc",
-        "hidl_utils.cc",
+        "aidl_utils.cc",
         "libc_wrappers.cc",
-        "service.cc",
     ],
     generated_headers: [
-        "hidl_camera_build_version",
+        "aidl_camera_build_version",
     ],
     compile_multilib: "first",
     shared_libs: [
-        "android.hardware.camera.device@3.2",
-        "android.hardware.camera.device@3.3",
-        "android.hardware.camera.device@3.4",
-        "android.hardware.camera.device@3.5",
-        "android.hardware.camera.device@3.6",
-        "android.hardware.camera.device@3.7",
-        "android.hardware.camera.provider@2.4",
-        "android.hardware.camera.provider@2.5",
-        "android.hardware.camera.provider@2.6",
-        "android.hardware.camera.provider@2.7",
+        "android.hardware.camera.device-V1-ndk",
+        "android.hardware.camera.common-V1-ndk",
+        "android.hardware.camera.provider-V1-ndk",
         "android.hardware.graphics.mapper@2.0",
         "android.hardware.graphics.mapper@3.0",
         "android.hardware.graphics.mapper@4.0",
         "android.hardware.thermal@2.0",
         "libbinder",
+        "libbinder_ndk",
         "libbase",
         "libcamera_metadata",
         "libcutils",
@@ -117,7 +114,17 @@ cc_defaults {
         "lib_profiler",
     ],
     static_libs: [
-        "android.hardware.camera.common@1.0-helper",
+        "libaidlcommonsupport",
+    ],
+}
+
+cc_defaults {
+    name: "camera_service_defaults",
+    defaults: [
+        "camera_service_defaults_common",
+    ],
+    srcs: [
+        "aidl_service.cc",
     ],
     vintf_fragments: [":android.hardware.camera.provider@2.7-service-google.xml"],
 }
diff --git a/common/hal/hidl_service/CleanSpec.mk b/common/hal/aidl_service/CleanSpec.mk
index 4c964ca..4c964ca 100644
--- a/common/hal/hidl_service/CleanSpec.mk
+++ b/common/hal/aidl_service/CleanSpec.mk
diff --git a/common/hal/hidl_service/hidl_camera_build_version.inl b/common/hal/aidl_service/aidl_camera_build_version.inl
index 1d104c4..1d104c4 100644
--- a/common/hal/hidl_service/hidl_camera_build_version.inl
+++ b/common/hal/aidl_service/aidl_camera_build_version.inl
diff --git a/common/hal/aidl_service/aidl_camera_device.cc b/common/hal/aidl_service/aidl_camera_device.cc
new file mode 100644
index 0000000..9d6c869
--- /dev/null
+++ b/common/hal/aidl_service/aidl_camera_device.cc
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "GCH_AidlCameraDevice"
+//#define LOG_NDEBUG 0
+#include "aidl_camera_device.h"
+
+#include <log/log.h>
+
+#include "aidl_camera_device_session.h"
+#include "aidl_profiler.h"
+#include "aidl_utils.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace implementation {
+
+namespace aidl_utils = ::android::hardware::camera::implementation::aidl_utils;
+
+using aidl::android::hardware::camera::common::Status;
+using ::android::google_camera_hal::HalCameraMetadata;
+
+const std::string AidlCameraDevice::kDeviceVersion = "1.1";
+
+std::shared_ptr<AidlCameraDevice> AidlCameraDevice::Create(
+    std::unique_ptr<CameraDevice> google_camera_device) {
+  auto device = ndk::SharedRefBase::make<AidlCameraDevice>();
+  if (device == nullptr) {
+    ALOGE("%s: Cannot create a AidlCameraDevice.", __FUNCTION__);
+    return nullptr;
+  }
+
+  status_t res = device->Initialize(std::move(google_camera_device));
+  if (res != OK) {
+    ALOGE("%s: Initializing AidlCameraDevice failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return nullptr;
+  }
+
+  return device;
+}
+
+status_t AidlCameraDevice::Initialize(
+    std::unique_ptr<CameraDevice> google_camera_device) {
+  if (google_camera_device == nullptr) {
+    ALOGE("%s: google_camera_device is nullptr.", __FUNCTION__);
+    return BAD_VALUE;
+  }
+
+  camera_id_ = google_camera_device->GetPublicCameraId();
+  google_camera_device_ = std::move(google_camera_device);
+  aidl_profiler_ = AidlProfiler::Create(camera_id_);
+  if (aidl_profiler_ == nullptr) {
+    ALOGE("%s: Failed to create AidlProfiler.", __FUNCTION__);
+    return UNKNOWN_ERROR;
+  }
+  return OK;
+}
+
+ScopedAStatus AidlCameraDevice::getResourceCost(
+    CameraResourceCost* resource_cost) {
+  google_camera_hal::CameraResourceCost hal_cost;
+  if (resource_cost == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  status_t res = google_camera_device_->GetResourceCost(&hal_cost);
+  if (res != OK) {
+    ALOGE("%s: Getting resource cost failed for camera %u: %s(%d)",
+          __FUNCTION__, camera_id_, strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  res = aidl_utils::ConvertToAidlResourceCost(hal_cost, resource_cost);
+  if (res != OK) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDevice::getCameraCharacteristics(
+    CameraMetadata* characteristics_ret) {
+  if (characteristics_ret == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  characteristics_ret->metadata.clear();
+  std::unique_ptr<HalCameraMetadata> characteristics;
+  status_t res =
+      google_camera_device_->GetCameraCharacteristics(&characteristics);
+  if (res != OK) {
+    ALOGE("%s: Getting camera characteristics for camera %u failed: %s(%d)",
+          __FUNCTION__, camera_id_, strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  if (characteristics == nullptr) {
+    ALOGE("%s: Camera characteristics for camera %u is nullptr.", __FUNCTION__,
+          camera_id_);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  uint32_t metadata_size = characteristics->GetCameraMetadataSize();
+  uint8_t* chars_p = (uint8_t*)characteristics->GetRawCameraMetadata();
+  characteristics_ret->metadata.assign(chars_p, chars_p + metadata_size);
+
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDevice::setTorchMode(bool on) {
+  google_camera_hal::TorchMode hal_torch_mode;
+  hal_torch_mode = on ? google_camera_hal::TorchMode::kOn
+                      : google_camera_hal::TorchMode::kOff;
+  auto res = google_camera_device_->SetTorchMode(hal_torch_mode);
+  return aidl_utils::ConvertToAidlReturn(res);
+}
+
+ScopedAStatus AidlCameraDevice::turnOnTorchWithStrengthLevel(
+    int32_t torch_strength) {
+  status_t res =
+      google_camera_device_->TurnOnTorchWithStrengthLevel(torch_strength);
+  return aidl_utils::ConvertToAidlReturn(res);
+}
+
+ScopedAStatus AidlCameraDevice::getTorchStrengthLevel(int32_t* strength_level) {
+  if (strength_level == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *strength_level = 0;
+  int32_t torch_strength;
+  status_t res = google_camera_device_->GetTorchStrengthLevel(torch_strength);
+  if (res != OK) {
+    ALOGE(
+        "%s: Getting camera flash unit torch strength level for camera %u "
+        "failed: %s(%d)",
+        __FUNCTION__, camera_id_, strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  *strength_level = torch_strength;
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDevice::getPhysicalCameraCharacteristics(
+    const std::string& physicalCameraId, CameraMetadata* characteristics_ret) {
+  if (characteristics_ret == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  characteristics_ret->metadata.clear();
+  std::unique_ptr<HalCameraMetadata> physical_characteristics;
+  uint32_t physical_camera_id = atoi(physicalCameraId.c_str());
+  status_t res = google_camera_device_->GetPhysicalCameraCharacteristics(
+      physical_camera_id, &physical_characteristics);
+  if (res != OK) {
+    ALOGE("%s: Getting physical characteristics for camera %u failed: %s(%d)",
+          __FUNCTION__, camera_id_, strerror(-res), res);
+    return aidl_utils::ConvertToAidlReturn(res);
+  }
+
+  if (physical_characteristics == nullptr) {
+    ALOGE("%s: Physical characteristics for camera %u is nullptr.",
+          __FUNCTION__, physical_camera_id);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  uint32_t metadata_size = physical_characteristics->GetCameraMetadataSize();
+  uint8_t* physical_characteristics_p =
+      (uint8_t*)physical_characteristics->GetRawCameraMetadata();
+  characteristics_ret->metadata.assign(
+      physical_characteristics_p, physical_characteristics_p + metadata_size);
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDevice::open(
+    const std::shared_ptr<ICameraDeviceCallback>& callback,
+    std::shared_ptr<ICameraDeviceSession>* session_ret) {
+  if (session_ret == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *session_ret = nullptr;
+  auto profiler = aidl_profiler_->MakeScopedProfiler(
+      AidlProfiler::ScopedType::kOpen,
+      google_camera_device_->GetProfiler(camera_id_,
+                                         aidl_profiler_->GetLatencyFlag()),
+      google_camera_device_->GetProfiler(camera_id_,
+                                         aidl_profiler_->GetFpsFlag()));
+
+  std::unique_ptr<google_camera_hal::CameraDeviceSession> session;
+  status_t res = google_camera_device_->CreateCameraDeviceSession(&session);
+  if (res != OK || session == nullptr) {
+    ALOGE("%s: Creating CameraDeviceSession failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return aidl_utils::ConvertToAidlReturn(res);
+  }
+
+  auto aidl_session = AidlCameraDeviceSession::Create(
+      callback, std::move(session), aidl_profiler_);
+  if (aidl_session == nullptr) {
+    ALOGE("%s: Creating AidlCameraDeviceSession failed.", __FUNCTION__);
+    return aidl_utils::ConvertToAidlReturn(res);
+  }
+  *session_ret = aidl_session;
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDevice::openInjectionSession(
+    const std::shared_ptr<ICameraDeviceCallback>&,
+    std::shared_ptr<ICameraInjectionSession>* session) {
+  if (session == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *session = nullptr;
+  return ScopedAStatus::fromServiceSpecificError(
+      static_cast<int32_t>(Status::OPERATION_NOT_SUPPORTED));
+}
+
+binder_status_t AidlCameraDevice::dump(int fd, const char** /*args*/,
+                                       uint32_t /*numArgs*/) {
+  google_camera_device_->DumpState(fd);
+  return OK;
+}
+
+ScopedAStatus AidlCameraDevice::isStreamCombinationSupported(
+    const StreamConfiguration& streams, bool* supported) {
+  if (supported == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *supported = false;
+  google_camera_hal::StreamConfiguration stream_config;
+  status_t res = aidl_utils::ConvertToHalStreamConfig(streams, &stream_config);
+  if (res != OK) {
+    ALOGE("%s: ConverToHalStreamConfig fail", __FUNCTION__);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  *supported =
+      google_camera_device_->IsStreamCombinationSupported(stream_config);
+  return ScopedAStatus::ok();
+}
+
+}  // namespace implementation
+}  // namespace device
+}  // namespace camera
+}  // namespace hardware
+}  // namespace android
diff --git a/common/hal/aidl_service/aidl_camera_device.h b/common/hal/aidl_service/aidl_camera_device.h
new file mode 100644
index 0000000..86b7263
--- /dev/null
+++ b/common/hal/aidl_service/aidl_camera_device.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_H_
+
+#include <aidl/android/hardware/camera/device/BnCameraDevice.h>
+#include <aidl/android/hardware/camera/device/ICameraDeviceCallback.h>
+
+#include "aidl_profiler.h"
+#include "camera_device.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace implementation {
+
+using aidl::android::hardware::camera::common::CameraResourceCost;
+using aidl::android::hardware::camera::device::BnCameraDevice;
+using aidl::android::hardware::camera::device::CameraMetadata;
+using aidl::android::hardware::camera::device::ICameraDevice;
+using aidl::android::hardware::camera::device::ICameraDeviceCallback;
+using aidl::android::hardware::camera::device::ICameraDeviceSession;
+using aidl::android::hardware::camera::device::ICameraInjectionSession;
+using aidl::android::hardware::camera::device::StreamConfiguration;
+using ::android::hardware::camera::implementation::AidlProfiler;
+using ndk::ScopedAStatus;
+using ndk::ScopedFileDescriptor;
+
+using ::android::google_camera_hal::CameraDevice;
+
+// AidlCameraDevice implements the AIDL camera device interface, ICameraDevice,
+// using Google Camera HAL to provide information about the associated camera
+// device.
+class AidlCameraDevice : public BnCameraDevice {
+ public:
+  static const std::string kDeviceVersion;
+
+  // Create a AidlCameraDevice.
+  // google_camera_device is a google camera device that AidlCameraDevice
+  // is going to manage. Creating a AidlCameraDevice will fail if
+  // google_camera_device is nullptr.
+  static std::shared_ptr<AidlCameraDevice> Create(
+      std::unique_ptr<CameraDevice> google_camera_device);
+  virtual ~AidlCameraDevice() = default;
+
+  binder_status_t dump(int fd, const char**, uint32_t) override;
+
+  // Override functions in ICameraDevice
+  ScopedAStatus getCameraCharacteristics(
+      CameraMetadata* characteristics) override;
+
+  ScopedAStatus getPhysicalCameraCharacteristics(
+      const std::string& in_physicalCameraId,
+      CameraMetadata* characteristics) override;
+
+  ScopedAStatus getResourceCost(CameraResourceCost* resource_cost) override;
+
+  ScopedAStatus isStreamCombinationSupported(
+      const StreamConfiguration& in_streams, bool* supported) override;
+
+  ScopedAStatus open(const std::shared_ptr<ICameraDeviceCallback>& in_callback,
+                     std::shared_ptr<ICameraDeviceSession>* session) override;
+
+  ScopedAStatus openInjectionSession(
+      const std::shared_ptr<ICameraDeviceCallback>& in_callback,
+      std::shared_ptr<ICameraInjectionSession>* session) override;
+
+  ScopedAStatus setTorchMode(bool on) override;
+
+  ScopedAStatus turnOnTorchWithStrengthLevel(int32_t torchStrength) override;
+
+  ScopedAStatus getTorchStrengthLevel(int32_t* strength_level) override;
+
+  // End of override functions in ICameraDevice
+  AidlCameraDevice() = default;
+
+ private:
+  status_t Initialize(std::unique_ptr<CameraDevice> google_camera_device);
+
+  std::unique_ptr<CameraDevice> google_camera_device_;
+  uint32_t camera_id_ = 0;
+  std::shared_ptr<AidlProfiler> aidl_profiler_;
+};
+
+}  // namespace implementation
+}  // namespace device
+}  // namespace camera
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_H_
diff --git a/common/hal/hidl_service/hidl_camera_device_session.cc b/common/hal/aidl_service/aidl_camera_device_session.cc
index 3af335e..9af6de1 100644
--- a/common/hal/hidl_service/hidl_camera_device_session.cc
+++ b/common/hal/aidl_service/aidl_camera_device_session.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "GCH_HidlCameraDeviceSession"
+#define LOG_TAG "GCH_AidlCameraDeviceSession"
 #define ATRACE_TAG ATRACE_TAG_CAMERA
 //#define LOG_NDEBUG 0
-#include "hidl_camera_device_session.h"
+#include "aidl_camera_device_session.h"
 
 #include <cutils/properties.h>
 #include <cutils/trace.h>
@@ -25,47 +25,46 @@
 #include <malloc.h>
 #include <utils/Trace.h>
 
-#include "hidl_profiler.h"
-#include "hidl_utils.h"
-
+#include "aidl_profiler.h"
+#include "aidl_utils.h"
 namespace android {
 namespace hardware {
 namespace camera {
 namespace device {
-namespace V3_7 {
 namespace implementation {
 
-namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
-
-using ::android::hardware::camera::device::V3_2::NotifyMsg;
-using ::android::hardware::camera::device::V3_2::StreamBuffer;
-using ::android::hardware::camera::device::V3_4::CaptureResult;
-using ::android::hardware::camera::device::V3_5::BufferRequest;
-using ::android::hardware::camera::device::V3_5::BufferRequestStatus;
-using ::android::hardware::camera::device::V3_5::StreamBufferRet;
-using ::android::hardware::camera::device::V3_5::StreamBuffersVal;
-using ::android::hardware::camera::device::V3_6::HalStreamConfiguration;
+namespace aidl_utils = ::android::hardware::camera::implementation::aidl_utils;
+
+using aidl::android::hardware::camera::common::Status;
+using aidl::android::hardware::camera::device::BufferRequest;
+using aidl::android::hardware::camera::device::BufferRequestStatus;
+using aidl::android::hardware::camera::device::CaptureResult;
+using aidl::android::hardware::camera::device::HalStream;
+using aidl::android::hardware::camera::device::NotifyMsg;
+using aidl::android::hardware::camera::device::StreamBuffer;
+using aidl::android::hardware::camera::device::StreamBufferRet;
+using aidl::android::hardware::camera::device::StreamBuffersVal;
+using aidl_utils::ConvertToAidlReturn;
 using ::android::hardware::thermal::V1_0::ThermalStatus;
 using ::android::hardware::thermal::V1_0::ThermalStatusCode;
 using ::android::hardware::thermal::V2_0::Temperature;
 using ::android::hardware::thermal::V2_0::TemperatureType;
 
-std::unique_ptr<HidlCameraDeviceSession> HidlCameraDeviceSession::Create(
-    const sp<V3_2::ICameraDeviceCallback>& callback,
+std::shared_ptr<AidlCameraDeviceSession> AidlCameraDeviceSession::Create(
+    const std::shared_ptr<ICameraDeviceCallback>& callback,
     std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
-    std::shared_ptr<HidlProfiler> hidl_profiler) {
-  ATRACE_NAME("HidlCameraDeviceSession::Create");
-  auto session =
-      std::unique_ptr<HidlCameraDeviceSession>(new HidlCameraDeviceSession());
+    std::shared_ptr<AidlProfiler> aidl_profiler) {
+  ATRACE_NAME("AidlCameraDeviceSession::Create");
+  auto session = ndk::SharedRefBase::make<AidlCameraDeviceSession>();
   if (session == nullptr) {
-    ALOGE("%s: Cannot create a HidlCameraDeviceSession.", __FUNCTION__);
+    ALOGE("%s: Cannot create a AidlCameraDeviceSession.", __FUNCTION__);
     return nullptr;
   }
 
   status_t res =
-      session->Initialize(callback, std::move(device_session), hidl_profiler);
+      session->Initialize(callback, std::move(device_session), aidl_profiler);
   if (res != OK) {
-    ALOGE("%s: Initializing HidlCameraDeviceSession failed: %s(%d)",
+    ALOGE("%s: Initializing AidlCameraDeviceSession failed: %s(%d)",
           __FUNCTION__, strerror(-res), res);
     return nullptr;
   }
@@ -73,18 +72,18 @@ std::unique_ptr<HidlCameraDeviceSession> HidlCameraDeviceSession::Create(
   return session;
 }
 
-HidlCameraDeviceSession::~HidlCameraDeviceSession() {
-  ATRACE_NAME("HidlCameraDeviceSession::~HidlCameraDeviceSession");
+AidlCameraDeviceSession::~AidlCameraDeviceSession() {
+  ATRACE_NAME("AidlCameraDeviceSession::~AidlCameraDeviceSession");
   close();
   // camera's closing, so flush any unused malloc pages
   mallopt(M_PURGE, 0);
 }
 
-void HidlCameraDeviceSession::ProcessCaptureResult(
+void AidlCameraDeviceSession::ProcessCaptureResult(
     std::unique_ptr<google_camera_hal::CaptureResult> hal_result) {
-  std::shared_lock lock(hidl_device_callback_lock_);
-  if (hidl_device_callback_ == nullptr) {
-    ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
+  std::shared_lock lock(aidl_device_callback_lock_);
+  if (aidl_device_callback_ == nullptr) {
+    ALOGE("%s: aidl_device_callback_ is nullptr", __FUNCTION__);
     return;
   }
 
@@ -96,66 +95,72 @@ void HidlCameraDeviceSession::ProcessCaptureResult(
       num_pending_first_frame_buffers_ -= hal_result->output_buffers.size();
       if (num_pending_first_frame_buffers_ == 0) {
         ALOGI("%s: First frame done", __FUNCTION__);
-        hidl_profiler_->FirstFrameEnd();
+        aidl_profiler_->FirstFrameEnd();
         ATRACE_ASYNC_END("first_frame", 0);
         ATRACE_ASYNC_END("switch_mode", 0);
       }
     }
   }
   for (auto& buffer : hal_result->output_buffers) {
-    hidl_profiler_->ProfileFrameRate("Stream " +
+    aidl_profiler_->ProfileFrameRate("Stream " +
                                      std::to_string(buffer.stream_id));
   }
 
-  hidl_vec<CaptureResult> hidl_results(1);
-  status_t res = hidl_utils::ConvertToHidlCaptureResult(
-      result_metadata_queue_.get(), std::move(hal_result), &hidl_results[0]);
+  std::vector<CaptureResult> aidl_results(1);
+  status_t res = aidl_utils::ConvertToAidlCaptureResult(
+      result_metadata_queue_.get(), std::move(hal_result), &aidl_results[0]);
   if (res != OK) {
-    ALOGE("%s: Converting to HIDL result failed: %s(%d)", __FUNCTION__,
+    ALOGE("%s: Converting to AIDL result failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return;
   }
 
-  auto hidl_res = hidl_device_callback_->processCaptureResult_3_4(hidl_results);
-  if (!hidl_res.isOk()) {
+  auto aidl_res = aidl_device_callback_->processCaptureResult(aidl_results);
+  if (!aidl_res.isOk()) {
     ALOGE("%s: processCaptureResult transaction failed: %s.", __FUNCTION__,
-          hidl_res.description().c_str());
+          aidl_res.getMessage());
     return;
   }
 }
 
-void HidlCameraDeviceSession::NotifyHalMessage(
+void AidlCameraDeviceSession::NotifyHalMessage(
     const google_camera_hal::NotifyMessage& hal_message) {
-  std::shared_lock lock(hidl_device_callback_lock_);
-  if (hidl_device_callback_ == nullptr) {
-    ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
+  std::shared_lock lock(aidl_device_callback_lock_);
+  if (aidl_device_callback_ == nullptr) {
+    ALOGE("%s: aidl_device_callback_ is nullptr", __FUNCTION__);
     return;
   }
 
-  hidl_vec<NotifyMsg> hidl_messages(1);
+  std::vector<NotifyMsg> aidl_messages(1);
   status_t res =
-      hidl_utils::ConverToHidlNotifyMessage(hal_message, &hidl_messages[0]);
+      aidl_utils::ConverToAidlNotifyMessage(hal_message, &aidl_messages[0]);
   if (res != OK) {
-    ALOGE("%s: Converting to HIDL message failed: %s(%d)", __FUNCTION__,
+    ALOGE("%s: Converting to AIDL message failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return;
   }
 
-  auto hidl_res = hidl_device_callback_->notify(hidl_messages);
-  if (!hidl_res.isOk()) {
+  auto aidl_res = aidl_device_callback_->notify(aidl_messages);
+  if (!aidl_res.isOk()) {
     ALOGE("%s: notify transaction failed: %s.", __FUNCTION__,
-          hidl_res.description().c_str());
+          aidl_res.getMessage());
     return;
   }
 }
 
+static void cleanupHandles(std::vector<native_handle_t*>& handles_to_delete) {
+  for (auto& handle : handles_to_delete) {
+    native_handle_delete(handle);
+  }
+}
+
 google_camera_hal::BufferRequestStatus
-HidlCameraDeviceSession::RequestStreamBuffers(
+AidlCameraDeviceSession::RequestStreamBuffers(
     const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
     std::vector<google_camera_hal::BufferReturn>* hal_buffer_returns) {
-  std::shared_lock lock(hidl_device_callback_lock_);
-  if (hidl_device_callback_ == nullptr) {
-    ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
+  std::shared_lock lock(aidl_device_callback_lock_);
+  if (aidl_device_callback_ == nullptr) {
+    ALOGE("%s: aidl_device_callback_ is nullptr", __FUNCTION__);
     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
   }
 
@@ -164,32 +169,28 @@ HidlCameraDeviceSession::RequestStreamBuffers(
     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
   }
 
-  hidl_vec<BufferRequest> hidl_buffer_requests;
-  status_t res = hidl_utils::ConvertToHidlBufferRequest(hal_buffer_requests,
-                                                        &hidl_buffer_requests);
+  std::vector<BufferRequest> aidl_buffer_requests;
+  status_t res = aidl_utils::ConvertToAidlBufferRequest(hal_buffer_requests,
+                                                        &aidl_buffer_requests);
   if (res != OK) {
-    ALOGE("%s: Converting to Hidl buffer request failed: %s(%d)", __FUNCTION__,
+    ALOGE("%s: Converting to Aidl buffer request failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
   }
 
-  BufferRequestStatus hidl_status;
-  hidl_vec<StreamBufferRet> stream_buffer_returns;
-  auto cb_status = hidl_device_callback_->requestStreamBuffers(
-      hidl_buffer_requests, [&hidl_status, &stream_buffer_returns](
-                                BufferRequestStatus status_ret,
-                                const hidl_vec<StreamBufferRet>& buffer_ret) {
-        hidl_status = status_ret;
-        stream_buffer_returns = std::move(buffer_ret);
-      });
+  BufferRequestStatus aidl_status;
+  std::vector<StreamBufferRet> stream_buffer_returns;
+  auto cb_status = aidl_device_callback_->requestStreamBuffers(
+      aidl_buffer_requests, &stream_buffer_returns, &aidl_status);
+
   if (!cb_status.isOk()) {
     ALOGE("%s: Transaction request stream buffers error: %s", __FUNCTION__,
-          cb_status.description().c_str());
+          cb_status.getMessage());
     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
   }
 
   google_camera_hal::BufferRequestStatus hal_buffer_request_status;
-  res = hidl_utils::ConvertToHalBufferRequestStatus(hidl_status,
+  res = aidl_utils::ConvertToHalBufferRequestStatus(aidl_status,
                                                     &hal_buffer_request_status);
   if (res != OK) {
     ALOGE("%s: Converting to Hal buffer request status failed: %s(%d)",
@@ -198,10 +199,10 @@ HidlCameraDeviceSession::RequestStreamBuffers(
   }
 
   hal_buffer_returns->clear();
-  // Converting HIDL stream buffer returns to HAL stream buffer returns.
+  // Converting AIDL stream buffer returns to HAL stream buffer returns.
   for (auto& stream_buffer_return : stream_buffer_returns) {
     google_camera_hal::BufferReturn hal_buffer_return;
-    res = hidl_utils::ConvertToHalBufferReturnStatus(stream_buffer_return,
+    res = aidl_utils::ConvertToHalBufferReturnStatus(stream_buffer_return,
                                                      &hal_buffer_return);
     if (res != OK) {
       ALOGE("%s: Converting to Hal buffer return status failed: %s(%d)",
@@ -209,22 +210,23 @@ HidlCameraDeviceSession::RequestStreamBuffers(
       return google_camera_hal::BufferRequestStatus::kFailedUnknown;
     }
 
-    if (stream_buffer_return.val.getDiscriminator() ==
-        V3_5::StreamBuffersVal::hidl_discriminator::buffers) {
-      const hidl_vec<StreamBuffer>& hidl_buffers =
-          stream_buffer_return.val.buffers();
-      for (auto& hidl_buffer : hidl_buffers) {
+    using Tag = aidl::android::hardware::camera::device::StreamBuffersVal::Tag;
+    if (stream_buffer_return.val.getTag() == Tag::buffers) {
+      const std::vector<StreamBuffer>& aidl_buffers =
+          stream_buffer_return.val.get<Tag::buffers>();
+      std::vector<native_handle_t*> native_handles_to_delete;
+      for (auto& aidl_buffer : aidl_buffers) {
         google_camera_hal::StreamBuffer hal_buffer = {};
-        hidl_utils::ConvertToHalStreamBuffer(hidl_buffer, &hal_buffer);
+        aidl_utils::ConvertToHalStreamBuffer(aidl_buffer, &hal_buffer,
+                                             &native_handles_to_delete);
         if (res != OK) {
           ALOGE("%s: Converting to Hal stream buffer failed: %s(%d)",
                 __FUNCTION__, strerror(-res), res);
           return google_camera_hal::BufferRequestStatus::kFailedUnknown;
         }
 
-        if (hidl_buffer.acquireFence.getNativeHandle() != nullptr) {
-          hal_buffer.acquire_fence =
-              native_handle_clone(hidl_buffer.acquireFence.getNativeHandle());
+        if (!aidl_utils::IsAidlNativeHandleNull(aidl_buffer.acquireFence)) {
+          hal_buffer.acquire_fence = dupFromAidl(aidl_buffer.acquireFence);
           if (hal_buffer.acquire_fence == nullptr) {
             ALOGE("%s: Cloning Hal stream buffer acquire fence failed",
                   __FUNCTION__);
@@ -234,27 +236,32 @@ HidlCameraDeviceSession::RequestStreamBuffers(
         hal_buffer.release_fence = nullptr;
         // If buffer handle is not null, we need to import buffer handle and
         // return to the caller.
-        if (hidl_buffer.buffer.getNativeHandle() != nullptr) {
+        if (!aidl_utils::IsAidlNativeHandleNull(aidl_buffer.buffer)) {
+          native_handle_t* aidl_buffer_native_handle =
+              makeFromAidl(aidl_buffer.buffer);
           if (buffer_mapper_v4_ != nullptr) {
             hal_buffer.buffer = ImportBufferHandle<
                 android::hardware::graphics::mapper::V4_0::IMapper,
                 android::hardware::graphics::mapper::V4_0::Error>(
-                buffer_mapper_v4_, hidl_buffer.buffer);
+                buffer_mapper_v4_, aidl_buffer_native_handle);
           } else if (buffer_mapper_v3_ != nullptr) {
             hal_buffer.buffer = ImportBufferHandle<
                 android::hardware::graphics::mapper::V3_0::IMapper,
                 android::hardware::graphics::mapper::V3_0::Error>(
-                buffer_mapper_v3_, hidl_buffer.buffer);
+                buffer_mapper_v3_, aidl_buffer_native_handle);
           } else {
             hal_buffer.buffer = ImportBufferHandle<
                 android::hardware::graphics::mapper::V2_0::IMapper,
                 android::hardware::graphics::mapper::V2_0::Error>(
-                buffer_mapper_v2_, hidl_buffer.buffer);
+                buffer_mapper_v2_, aidl_buffer_native_handle);
           }
+          native_handle_delete(aidl_buffer_native_handle);
         }
 
         hal_buffer_return.val.buffers.push_back(hal_buffer);
       }
+
+      cleanupHandles(native_handles_to_delete);
     }
 
     hal_buffer_returns->push_back(hal_buffer_return);
@@ -264,7 +271,7 @@ HidlCameraDeviceSession::RequestStreamBuffers(
 }
 
 template <class T, class U>
-buffer_handle_t HidlCameraDeviceSession::ImportBufferHandle(
+buffer_handle_t AidlCameraDeviceSession::ImportBufferHandle(
     const sp<T> buffer_mapper_, const hidl_handle& buffer_hidl_handle) {
   U mapper_error;
   buffer_handle_t imported_buffer_handle;
@@ -283,37 +290,37 @@ buffer_handle_t HidlCameraDeviceSession::ImportBufferHandle(
   return imported_buffer_handle;
 }
 
-void HidlCameraDeviceSession::ReturnStreamBuffers(
+void AidlCameraDeviceSession::ReturnStreamBuffers(
     const std::vector<google_camera_hal::StreamBuffer>& return_hal_buffers) {
-  std::shared_lock lock(hidl_device_callback_lock_);
-  if (hidl_device_callback_ == nullptr) {
-    ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
+  std::shared_lock lock(aidl_device_callback_lock_);
+  if (aidl_device_callback_ == nullptr) {
+    ALOGE("%s: aidl_device_callback_ is nullptr", __FUNCTION__);
     return;
   }
 
   status_t res = OK;
-  hidl_vec<StreamBuffer> hidl_return_buffers;
-  hidl_return_buffers.resize(return_hal_buffers.size());
+  std::vector<StreamBuffer> aidl_return_buffers;
+  aidl_return_buffers.resize(return_hal_buffers.size());
   for (uint32_t i = 0; i < return_hal_buffers.size(); i++) {
-    res = hidl_utils::ConvertToHidlStreamBuffer(return_hal_buffers[i],
-                                                &hidl_return_buffers[i]);
+    res = aidl_utils::ConvertToAidlStreamBuffer(return_hal_buffers[i],
+                                                &aidl_return_buffers[i]);
     if (res != OK) {
-      ALOGE("%s: Converting to Hidl stream buffer failed: %s(%d)", __FUNCTION__,
+      ALOGE("%s: Converting to Aidl stream buffer failed: %s(%d)", __FUNCTION__,
             strerror(-res), res);
       return;
     }
   }
 
-  auto hidl_res =
-      hidl_device_callback_->returnStreamBuffers(hidl_return_buffers);
-  if (!hidl_res.isOk()) {
-    ALOGE("%s: return stream buffers transaction failed: %s.", __FUNCTION__,
-          hidl_res.description().c_str());
+  auto aidl_res =
+      aidl_device_callback_->returnStreamBuffers(aidl_return_buffers);
+  if (!aidl_res.isOk()) {
+    ALOGE("%s: return stream buffers transaction failed: %s", __FUNCTION__,
+          aidl_res.getMessage());
     return;
   }
 }
 
-status_t HidlCameraDeviceSession::InitializeBufferMapper() {
+status_t AidlCameraDeviceSession::InitializeBufferMapper() {
   buffer_mapper_v4_ =
       android::hardware::graphics::mapper::V4_0::IMapper::getService();
   if (buffer_mapper_v4_ != nullptr) {
@@ -336,18 +343,18 @@ status_t HidlCameraDeviceSession::InitializeBufferMapper() {
   return UNKNOWN_ERROR;
 }
 
-status_t HidlCameraDeviceSession::Initialize(
-    const sp<V3_2::ICameraDeviceCallback>& callback,
+status_t AidlCameraDeviceSession::Initialize(
+    const std::shared_ptr<ICameraDeviceCallback>& callback,
     std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
-    std::shared_ptr<HidlProfiler> hidl_profiler) {
-  ATRACE_NAME("HidlCameraDeviceSession::Initialize");
+    std::shared_ptr<AidlProfiler> aidl_profiler) {
+  ATRACE_NAME("AidlCameraDeviceSession::Initialize");
   if (device_session == nullptr) {
     ALOGE("%s: device_session is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  if (hidl_profiler == nullptr) {
-    ALOGE("%s: hidl_profiler is nullptr.", __FUNCTION__);
+  if (aidl_profiler == nullptr) {
+    ALOGE("%s: aidl_profiler is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
@@ -369,13 +376,6 @@ status_t HidlCameraDeviceSession::Initialize(
     return res;
   }
 
-  // Cast V3.2 callback to V3.5
-  auto cast_res = ICameraDeviceCallback::castFrom(callback);
-  if (!cast_res.isOk()) {
-    ALOGE("%s: Cannot convert to V3.5 device callback.", __FUNCTION__);
-    return UNKNOWN_ERROR;
-  }
-
   // Initialize buffer mapper
   res = InitializeBufferMapper();
   if (res != OK) {
@@ -390,15 +390,15 @@ status_t HidlCameraDeviceSession::Initialize(
     // Continue without getting thermal information.
   }
 
-  hidl_device_callback_ = cast_res;
+  aidl_device_callback_ = callback;
   device_session_ = std::move(device_session);
-  hidl_profiler_ = hidl_profiler;
+  aidl_profiler_ = aidl_profiler;
 
   SetSessionCallbacks();
   return OK;
 }
 
-void HidlCameraDeviceSession::SetSessionCallbacks() {
+void AidlCameraDeviceSession::SetSessionCallbacks() {
   google_camera_hal::CameraDeviceSessionCallback session_callback = {
       .process_capture_result = google_camera_hal::ProcessCaptureResultFunc(
           [this](std::unique_ptr<google_camera_hal::CaptureResult> result) {
@@ -438,7 +438,7 @@ void HidlCameraDeviceSession::SetSessionCallbacks() {
   device_session_->SetSessionCallback(session_callback, thermal_callback);
 }
 
-status_t HidlCameraDeviceSession::RegisterThermalChangedCallback(
+status_t AidlCameraDeviceSession::RegisterThermalChangedCallback(
     google_camera_hal::NotifyThrottlingFunc notify_throttling, bool filter_type,
     google_camera_hal::TemperatureType type) {
   std::lock_guard<std::mutex> lock(hidl_thermal_mutex_);
@@ -476,7 +476,7 @@ status_t HidlCameraDeviceSession::RegisterThermalChangedCallback(
   return OK;
 }
 
-void HidlCameraDeviceSession::UnregisterThermalChangedCallback() {
+void AidlCameraDeviceSession::UnregisterThermalChangedCallback() {
   std::lock_guard<std::mutex> lock(hidl_thermal_mutex_);
   if (thermal_changed_callback_ == nullptr) {
     // no-op if no thermal changed callback is registered.
@@ -500,7 +500,7 @@ void HidlCameraDeviceSession::UnregisterThermalChangedCallback() {
   thermal_changed_callback_ = nullptr;
 }
 
-status_t HidlCameraDeviceSession::CreateMetadataQueue(
+status_t AidlCameraDeviceSession::CreateMetadataQueue(
     std::unique_ptr<MetadataQueue>* metadata_queue, uint32_t default_size_bytes,
     const char* override_size_property) {
   if (metadata_queue == nullptr) {
@@ -516,8 +516,9 @@ status_t HidlCameraDeviceSession::CreateMetadataQueue(
           size);
   }
 
-  *metadata_queue = std::make_unique<MetadataQueue>(
-      static_cast<size_t>(size), /*configureEventFlagWord=*/false);
+  *metadata_queue =
+      std::make_unique<MetadataQueue>(static_cast<size_t>(size),
+                                      /*configureEventFlagWord*/ false);
   if (!(*metadata_queue)->isValid()) {
     ALOGE("%s: Creating metadata queue (size %d) failed.", __FUNCTION__, size);
     return NO_INIT;
@@ -526,61 +527,68 @@ status_t HidlCameraDeviceSession::CreateMetadataQueue(
   return OK;
 }
 
-Return<void> HidlCameraDeviceSession::constructDefaultRequestSettings(
-    RequestTemplate type,
-    ICameraDeviceSession::constructDefaultRequestSettings_cb _hidl_cb) {
-  ATRACE_NAME("HidlCameraDeviceSession::constructDefaultRequestSettings");
-  V3_2::CameraMetadata hidl_metadata;
-
+ScopedAStatus AidlCameraDeviceSession::constructDefaultRequestSettings(
+    RequestTemplate type, CameraMetadata* aidl_return) {
+  ATRACE_NAME("AidlCameraDeviceSession::constructDefaultRequestSettings");
+  if (aidl_return == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  aidl_return->metadata.clear();
   if (device_session_ == nullptr) {
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_metadata);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
   google_camera_hal::RequestTemplate hal_type;
-  status_t res = hidl_utils::ConvertToHalTemplateType(type, &hal_type);
+  status_t res = aidl_utils::ConvertToHalTemplateType(type, &hal_type);
   if (res != OK) {
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_metadata);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
   }
 
   std::unique_ptr<google_camera_hal::HalCameraMetadata> settings = nullptr;
   res = device_session_->ConstructDefaultRequestSettings(hal_type, &settings);
   if (res != OK) {
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_metadata);
-    return Void();
+    return aidl_utils::ConvertToAidlReturn(res);
   }
 
   uint32_t metadata_size = settings->GetCameraMetadataSize();
-  hidl_metadata.setToExternal((uint8_t*)settings->ReleaseCameraMetadata(),
-                              metadata_size, /*shouldOwn=*/true);
-  _hidl_cb(Status::OK, hidl_metadata);
-
-  return Void();
+  uint8_t* settings_p = (uint8_t*)settings->ReleaseCameraMetadata();
+  aidl_return->metadata.assign(settings_p, settings_p + metadata_size);
+  return ScopedAStatus::ok();
 }
 
-Return<void> HidlCameraDeviceSession::configureStreams_3_7(
+ScopedAStatus AidlCameraDeviceSession::configureStreams(
     const StreamConfiguration& requestedConfiguration,
-    ICameraDeviceSession::configureStreams_3_6_cb _hidl_cb) {
-  ATRACE_NAME("HidlCameraDeviceSession::configureStreams_3_7");
-  HalStreamConfiguration hidl_hal_configs;
+    std::vector<HalStream>* aidl_return) {
+  ATRACE_NAME("AidlCameraDeviceSession::configureStreams");
+  if (aidl_return == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  aidl_return->clear();
   if (device_session_ == nullptr) {
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_hal_configs);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
   }
 
-  auto profiler = hidl_profiler_->MakeScopedProfiler(
-      HidlProfiler::ScopedType::kConfigureStream);
+  auto profiler = aidl_profiler_->MakeScopedProfiler(
+      AidlProfiler::ScopedType::kConfigureStream,
+      device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                   aidl_profiler_->GetLatencyFlag()),
+      device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                   aidl_profiler_->GetFpsFlag()));
 
   first_frame_requested_ = false;
   num_pending_first_frame_buffers_ = 0;
 
   google_camera_hal::StreamConfiguration hal_stream_config;
-  status_t res = hidl_utils::ConverToHalStreamConfig(requestedConfiguration,
-                                                     &hal_stream_config);
+  status_t res = aidl_utils::ConvertToHalStreamConfig(requestedConfiguration,
+                                                      &hal_stream_config);
   if (res != OK) {
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_hal_configs);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
   }
 
   std::vector<google_camera_hal::HalStream> hal_configured_streams;
@@ -589,78 +597,80 @@ Return<void> HidlCameraDeviceSession::configureStreams_3_7(
   if (res != OK) {
     ALOGE("%s: Configuring streams failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_hal_configs);
-    return Void();
+    return aidl_utils::ConvertToAidlReturn(res);
   }
 
-  res = hidl_utils::ConvertToHidlHalStreamConfig(hal_configured_streams,
-                                                 &hidl_hal_configs);
-  _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_hal_configs);
-
-  return Void();
+  res = aidl_utils::ConvertToAidlHalStreamConfig(hal_configured_streams,
+                                                 aidl_return);
+  if (res != OK) {
+    return aidl_utils::ConvertToAidlReturn(res);
+  }
+  return ScopedAStatus::ok();
 }
 
-Return<void> HidlCameraDeviceSession::getCaptureRequestMetadataQueue(
-    ICameraDeviceSession::getCaptureRequestMetadataQueue_cb _hidl_cb) {
-  _hidl_cb(*request_metadata_queue_->getDesc());
-  return Void();
+ScopedAStatus AidlCameraDeviceSession::getCaptureRequestMetadataQueue(
+    ::aidl::android::hardware::common::fmq::MQDescriptor<
+        int8_t, SynchronizedReadWrite>* aidl_return) {
+  *aidl_return = request_metadata_queue_->dupeDesc();
+  return ScopedAStatus::ok();
 }
 
-Return<void> HidlCameraDeviceSession::getCaptureResultMetadataQueue(
-    ICameraDeviceSession::getCaptureResultMetadataQueue_cb _hidl_cb) {
-  _hidl_cb(*result_metadata_queue_->getDesc());
-  return Void();
+ScopedAStatus AidlCameraDeviceSession::getCaptureResultMetadataQueue(
+    ::aidl::android::hardware::common::fmq::MQDescriptor<
+        int8_t, SynchronizedReadWrite>* aidl_return) {
+  *aidl_return = result_metadata_queue_->dupeDesc();
+  return ScopedAStatus::ok();
 }
 
-Return<void> HidlCameraDeviceSession::processCaptureRequest_3_7(
-    const hidl_vec<CaptureRequest>& requests,
-    const hidl_vec<BufferCache>& cachesToRemove,
-    processCaptureRequest_3_7_cb _hidl_cb) {
-  if (device_session_ == nullptr) {
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, 0);
-    return Void();
+ScopedAStatus AidlCameraDeviceSession::processCaptureRequest(
+    const std::vector<CaptureRequest>& requests,
+    const std::vector<BufferCache>& cachesToRemove, int32_t* aidl_return) {
+  if (aidl_return == nullptr || device_session_ == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
   }
-
+  *aidl_return = 0;
   bool profile_first_request = false;
   if (!first_frame_requested_) {
     first_frame_requested_ = true;
     profile_first_request = true;
-    ATRACE_BEGIN("HidlCameraDeviceSession::FirstRequest");
-    num_pending_first_frame_buffers_ =
-        requests[0].v3_4.v3_2.outputBuffers.size();
-    first_request_frame_number_ = requests[0].v3_4.v3_2.frameNumber;
-    hidl_profiler_->FirstFrameStart();
+    ATRACE_BEGIN("AidlCameraDeviceSession::FirstRequest");
+    num_pending_first_frame_buffers_ = requests[0].outputBuffers.size();
+    first_request_frame_number_ = requests[0].frameNumber;
+    aidl_profiler_->FirstFrameStart();
     ATRACE_ASYNC_BEGIN("first_frame", 0);
   }
 
   std::vector<google_camera_hal::BufferCache> hal_buffer_caches;
 
   status_t res =
-      hidl_utils::ConvertToHalBufferCaches(cachesToRemove, &hal_buffer_caches);
+      aidl_utils::ConvertToHalBufferCaches(cachesToRemove, &hal_buffer_caches);
   if (res != OK) {
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, 0);
     if (profile_first_request) {
       ATRACE_END();
     }
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
   }
 
   device_session_->RemoveBufferCache(hal_buffer_caches);
 
-  // Converting HIDL requests to HAL requests.
+  // Converting AIDL requests to HAL requests.
+  std::vector<native_handle_t*> handles_to_delete;
   std::vector<google_camera_hal::CaptureRequest> hal_requests;
   for (auto& request : requests) {
     google_camera_hal::CaptureRequest hal_request = {};
-    res = hidl_utils::ConvertToHalCaptureRequest(
-        request, request_metadata_queue_.get(), &hal_request);
+    res = aidl_utils::ConvertToHalCaptureRequest(
+        request, request_metadata_queue_.get(), &hal_request,
+        &handles_to_delete);
     if (res != OK) {
       ALOGE("%s: Converting to HAL capture request failed: %s(%d)",
             __FUNCTION__, strerror(-res), res);
-      _hidl_cb(hidl_utils::ConvertToHidlStatus(res), 0);
       if (profile_first_request) {
         ATRACE_END();
       }
-      return Void();
+      cleanupHandles(handles_to_delete);
+      return aidl_utils::ConvertToAidlReturn(res);
     }
 
     hal_requests.push_back(std::move(hal_request));
@@ -676,185 +686,119 @@ Return<void> HidlCameraDeviceSession::processCaptureRequest_3_7(
         __FUNCTION__, strerror(-res), res, num_processed_requests,
         hal_requests.size());
   }
-
-  _hidl_cb(hidl_utils::ConvertToHidlStatus(res), num_processed_requests);
+  if (num_processed_requests > INT_MAX) {
+    cleanupHandles(handles_to_delete);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *aidl_return = (int32_t)num_processed_requests;
   if (profile_first_request) {
     ATRACE_END();
   }
-  return Void();
+  cleanupHandles(handles_to_delete);
+  return aidl_utils::ConvertToAidlReturn(res);
 }
 
-Return<void> HidlCameraDeviceSession::signalStreamFlush(
-    const hidl_vec<int32_t>& /*streamIds*/, uint32_t /*streamConfigCounter*/) {
+ScopedAStatus AidlCameraDeviceSession::signalStreamFlush(
+    const std::vector<int32_t>&, int32_t) {
   // TODO(b/143902312): Implement this.
-  return Void();
+  return ScopedAStatus::ok();
 }
 
-Return<Status> HidlCameraDeviceSession::flush() {
-  ATRACE_NAME("HidlCameraDeviceSession::flush");
+ScopedAStatus AidlCameraDeviceSession::flush() {
+  ATRACE_NAME("AidlCameraDeviceSession::flush");
   ATRACE_ASYNC_BEGIN("switch_mode", 0);
   if (device_session_ == nullptr) {
-    return Status::INTERNAL_ERROR;
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
-  hidl_profiler_->SetLatencyProfiler(device_session_->GetProfiler(
-      hidl_profiler_->GetCameraId(), hidl_profiler_->GetLatencyFlag()));
-  hidl_profiler_->SetFpsProfiler(device_session_->GetProfiler(
-      hidl_profiler_->GetCameraId(), hidl_profiler_->GetFpsFlag()));
-  auto profiler =
-      hidl_profiler_->MakeScopedProfiler(HidlProfiler::ScopedType::kFlush);
+  auto profiler = aidl_profiler_->MakeScopedProfiler(
+      AidlProfiler::ScopedType::kFlush,
+      device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                   aidl_profiler_->GetLatencyFlag()),
+      device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                   aidl_profiler_->GetFpsFlag()));
 
   status_t res = device_session_->Flush();
   if (res != OK) {
     ALOGE("%s: Flushing device failed: %s(%d).", __FUNCTION__, strerror(-res),
           res);
-    return Status::INTERNAL_ERROR;
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
-  return Status::OK;
+  return ScopedAStatus::ok();
 }
 
-Return<void> HidlCameraDeviceSession::close() {
-  ATRACE_NAME("HidlCameraDeviceSession::close");
+ScopedAStatus AidlCameraDeviceSession::close() {
+  ATRACE_NAME("AidlCameraDeviceSession::close");
   if (device_session_ != nullptr) {
-    auto profiler =
-        hidl_profiler_->MakeScopedProfiler(HidlProfiler::ScopedType::kClose);
+    auto profiler = aidl_profiler_->MakeScopedProfiler(
+        AidlProfiler::ScopedType::kClose,
+        device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                     aidl_profiler_->GetLatencyFlag()),
+        device_session_->GetProfiler(aidl_profiler_->GetCameraId(),
+                                     aidl_profiler_->GetFpsFlag()));
     device_session_ = nullptr;
   }
-  return Void();
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraDeviceSession::switchToOffline(
+    const std::vector<int32_t>&,
+    CameraOfflineSessionInfo* out_offlineSessionInfo,
+    std::shared_ptr<ICameraOfflineSession>* aidl_return) {
+  *out_offlineSessionInfo = CameraOfflineSessionInfo();
+  *aidl_return = nullptr;
+  return ScopedAStatus::fromServiceSpecificError(
+      static_cast<int32_t>(Status::INTERNAL_ERROR));
 }
 
-Return<void> HidlCameraDeviceSession::isReconfigurationRequired(
-    const V3_2::CameraMetadata& oldSessionParams,
-    const V3_2::CameraMetadata& newSessionParams,
-    ICameraDeviceSession::isReconfigurationRequired_cb _hidl_cb) {
-  ATRACE_NAME("HidlCameraDeviceSession::isReconfigurationRequired");
+ScopedAStatus AidlCameraDeviceSession::isReconfigurationRequired(
+    const CameraMetadata& oldSessionParams,
+    const CameraMetadata& newSessionParams, bool* reconfiguration_required) {
+  ATRACE_NAME("AidlCameraDeviceSession::isReconfigurationRequired");
+  if (reconfiguration_required == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  *reconfiguration_required = true;
   std::unique_ptr<google_camera_hal::HalCameraMetadata> old_hal_session_metadata;
-  status_t res = hidl_utils::ConvertToHalMetadata(0, nullptr, oldSessionParams,
-                                                  &old_hal_session_metadata);
+  status_t res = aidl_utils::ConvertToHalMetadata(
+      0, nullptr, oldSessionParams.metadata, &old_hal_session_metadata);
   if (res != OK) {
     ALOGE("%s: Converting to old session metadata failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, true);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
   std::unique_ptr<google_camera_hal::HalCameraMetadata> new_hal_session_metadata;
-  res = hidl_utils::ConvertToHalMetadata(0, nullptr, newSessionParams,
+  res = aidl_utils::ConvertToHalMetadata(0, nullptr, newSessionParams.metadata,
                                          &new_hal_session_metadata);
   if (res != OK) {
     ALOGE("%s: Converting to new session metadata failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, true);
-    return Void();
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
-  bool reconfiguration_required = true;
   res = device_session_->IsReconfigurationRequired(
       old_hal_session_metadata.get(), new_hal_session_metadata.get(),
-      &reconfiguration_required);
+      reconfiguration_required);
 
   if (res != OK) {
     ALOGE("%s: IsReconfigurationRequired failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, true);
-    return Void();
-  }
-
-  _hidl_cb(Status::OK, reconfiguration_required);
-  return Void();
-}
-
-Return<void> HidlCameraDeviceSession::configureStreams(
-    const V3_2::StreamConfiguration&, configureStreams_cb _hidl_cb) {
-  _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_2::HalStreamConfiguration());
-  return Void();
-}
-Return<void> HidlCameraDeviceSession::configureStreams_3_3(
-    const V3_2::StreamConfiguration&, configureStreams_3_3_cb _hidl_cb) {
-  _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_3::HalStreamConfiguration());
-  return Void();
-}
-Return<void> HidlCameraDeviceSession::configureStreams_3_4(
-    const V3_4::StreamConfiguration&, configureStreams_3_4_cb _hidl_cb) {
-  _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_4::HalStreamConfiguration());
-  return Void();
-}
-
-Return<void> HidlCameraDeviceSession::configureStreams_3_5(
-    const V3_5::StreamConfiguration& requestedConfiguration,
-    configureStreams_3_5_cb _hidl_cb) {
-  configureStreams_3_6(
-      requestedConfiguration,
-      [_hidl_cb](Status s, device::V3_6::HalStreamConfiguration halConfig) {
-        V3_4::HalStreamConfiguration halConfig3_4;
-        halConfig3_4.streams.resize(halConfig.streams.size());
-        for (size_t i = 0; i < halConfig.streams.size(); i++) {
-          halConfig3_4.streams[i] = halConfig.streams[i].v3_4;
-        }
-        _hidl_cb(s, halConfig3_4);
-      });
-
-  return Void();
-}
-
-Return<void> HidlCameraDeviceSession::configureStreams_3_6(
-    const V3_5::StreamConfiguration& requestedConfiguration,
-    configureStreams_3_6_cb _hidl_cb) {
-  StreamConfiguration requestedConfiguration3_7;
-  requestedConfiguration3_7.streams.resize(
-      requestedConfiguration.v3_4.streams.size());
-  for (size_t i = 0; i < requestedConfiguration.v3_4.streams.size(); i++) {
-    requestedConfiguration3_7.streams[i].v3_4 =
-        requestedConfiguration.v3_4.streams[i];
-    requestedConfiguration3_7.streams[i].groupId = -1;
-  }
-  requestedConfiguration3_7.operationMode =
-      requestedConfiguration.v3_4.operationMode;
-  requestedConfiguration3_7.sessionParams =
-      requestedConfiguration.v3_4.sessionParams;
-  requestedConfiguration3_7.streamConfigCounter =
-      requestedConfiguration.streamConfigCounter;
-  requestedConfiguration3_7.multiResolutionInputImage = false;
-
-  configureStreams_3_7(requestedConfiguration3_7, _hidl_cb);
-  return Void();
-}
-
-Return<void> HidlCameraDeviceSession::switchToOffline(
-    const hidl_vec<int32_t>&, switchToOffline_cb _hidl_cb) {
-  _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_6::CameraOfflineSessionInfo(), nullptr);
-  return Void();
-}
-
-Return<void> HidlCameraDeviceSession::processCaptureRequest(
-    const hidl_vec<V3_2::CaptureRequest>& requests,
-    const hidl_vec<BufferCache>& cachesToRemove,
-    processCaptureRequest_cb _hidl_cb) {
-  hidl_vec<V3_4::CaptureRequest> requests_3_4;
-  requests_3_4.resize(requests.size());
-  for (uint32_t i = 0; i < requests_3_4.size(); i++) {
-    requests_3_4[i].v3_2 = requests[i];
-  }
-
-  return processCaptureRequest_3_4(requests_3_4, cachesToRemove, _hidl_cb);
-}
-
-Return<void> HidlCameraDeviceSession::processCaptureRequest_3_4(
-    const hidl_vec<V3_4::CaptureRequest>& requests,
-    const hidl_vec<BufferCache>& cachesToRemove,
-    processCaptureRequest_cb _hidl_cb) {
-  hidl_vec<V3_7::CaptureRequest> requests_3_7;
-  requests_3_7.resize(requests.size());
-  for (uint32_t i = 0; i < requests_3_7.size(); i++) {
-    requests_3_7[i].v3_4 = requests[i];
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
   }
 
-  return processCaptureRequest_3_7(requests_3_7, cachesToRemove, _hidl_cb);
+  return ScopedAStatus::ok();
 }
 
 }  // namespace implementation
-}  // namespace V3_7
 }  // namespace device
 }  // namespace camera
 }  // namespace hardware
diff --git a/common/hal/hidl_service/hidl_camera_device_session.h b/common/hal/aidl_service/aidl_camera_device_session.h
index ea2b600..e14604d 100644
--- a/common/hal/hidl_service/hidl_camera_device_session.h
+++ b/common/hal/aidl_service/aidl_camera_device_session.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,122 +14,104 @@
  * limitations under the License.
  */
 
-#ifndef HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_SESSION_H_
-#define HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_SESSION_H_
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_SESSION_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_SESSION_H_
 
-#include <android/hardware/camera/device/3.5/ICameraDeviceCallback.h>
-#include <android/hardware/camera/device/3.7/ICameraDevice.h>
-#include <android/hardware/camera/device/3.7/ICameraDeviceSession.h>
+#include <aidl/android/hardware/camera/device/BnCameraDeviceSession.h>
+#include <aidl/android/hardware/camera/device/ICameraDevice.h>
+#include <aidl/android/hardware/camera/device/ICameraDeviceCallback.h>
 #include <android/hardware/thermal/2.0/IThermal.h>
-#include <fmq/MessageQueue.h>
+#include <fmq/AidlMessageQueue.h>
 
 #include <shared_mutex>
 
+#include "aidl_profiler.h"
 #include "camera_device_session.h"
-#include "hidl_profiler.h"
 #include "hidl_thermal_utils.h"
 
 namespace android {
 namespace hardware {
 namespace camera {
 namespace device {
-namespace V3_7 {
 namespace implementation {
 
-using ::android::hardware::camera::common::V1_0::Status;
-using ::android::hardware::camera::device::V3_2::BufferCache;
-using ::android::hardware::camera::device::V3_2::RequestTemplate;
-using ::android::hardware::camera::device::V3_5::ICameraDeviceCallback;
-using ::android::hardware::camera::device::V3_7::CaptureRequest;
-using ::android::hardware::camera::device::V3_7::ICameraDeviceSession;
-using ::android::hardware::camera::device::V3_7::StreamConfiguration;
-using ::android::hardware::camera::implementation::HidlProfiler;
-
-using MetadataQueue =
-    ::android::hardware::MessageQueue<uint8_t, kSynchronizedReadWrite>;
-
-// HidlCameraDeviceSession implements the HIDL camera device session interface,
+using ::aidl::android::hardware::camera::device::BnCameraDeviceSession;
+using ::aidl::android::hardware::camera::device::BufferCache;
+using ::aidl::android::hardware::camera::device::CameraMetadata;
+using ::aidl::android::hardware::camera::device::CameraOfflineSessionInfo;
+using ::aidl::android::hardware::camera::device::CaptureRequest;
+using ::aidl::android::hardware::camera::device::HalStream;
+using ::aidl::android::hardware::camera::device::ICameraDeviceCallback;
+using ::aidl::android::hardware::camera::device::ICameraOfflineSession;
+using ::aidl::android::hardware::camera::device::RequestTemplate;
+using ::aidl::android::hardware::camera::device::StreamConfiguration;
+using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
+using ::android::hardware::camera::implementation::AidlProfiler;
+using ndk::ScopedAStatus;
+
+using MetadataQueue = AidlMessageQueue<int8_t, SynchronizedReadWrite>;
+
+// AidlCameraDeviceSession implements the AIDL camera device session interface,
 // ICameraDeviceSession, that contains the methods to configure and request
 // captures from an active camera device.
-class HidlCameraDeviceSession : public ICameraDeviceSession {
+class AidlCameraDeviceSession : public BnCameraDeviceSession {
  public:
-  // Create a HidlCameraDeviceSession.
+  // Create a AidlCameraDeviceSession.
   // device_session is a google camera device session that
-  // HidlCameraDeviceSession is going to manage. Creating a
-  // HidlCameraDeviceSession will fail if device_session is
+  // AidlCameraDeviceSession is going to manage. Creating a
+  // AidlCameraDeviceSession will fail if device_session is
   // nullptr.
-  static std::unique_ptr<HidlCameraDeviceSession> Create(
-      const sp<V3_2::ICameraDeviceCallback>& callback,
+  static std::shared_ptr<AidlCameraDeviceSession> Create(
+      const std::shared_ptr<ICameraDeviceCallback>& callback,
       std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
-      std::shared_ptr<HidlProfiler> hidl_profiler);
-
-  virtual ~HidlCameraDeviceSession();
-
-  // Override functions in ICameraDeviceSession
-  Return<void> configureStreams_3_7(
-      const StreamConfiguration& requestedConfiguration,
-      configureStreams_3_7_cb _hidl_cb) override;
-
-  Return<void> processCaptureRequest_3_7(
-      const hidl_vec<CaptureRequest>& requests,
-      const hidl_vec<BufferCache>& cachesToRemove,
-      processCaptureRequest_3_7_cb _hidl_cb) override;
-
-  Return<void> configureStreams_3_6(
-      const V3_5::StreamConfiguration& requestedConfiguration,
-      ICameraDeviceSession::configureStreams_3_6_cb _hidl_cb) override;
-
-  Return<void> switchToOffline(const hidl_vec<int32_t>& streamsToKeep,
-                               switchToOffline_cb _hidl_cb) override;
+      std::shared_ptr<AidlProfiler> aidl_profiler);
 
-  Return<void> constructDefaultRequestSettings(
-      RequestTemplate type,
-      ICameraDeviceSession::constructDefaultRequestSettings_cb _hidl_cb) override;
+  virtual ~AidlCameraDeviceSession();
 
-  Return<void> configureStreams_3_5(
-      const V3_5::StreamConfiguration& requestedConfiguration,
-      ICameraDeviceSession::configureStreams_3_5_cb _hidl_cb) override;
+  // functions in ICameraDeviceSession
 
-  Return<void> getCaptureRequestMetadataQueue(
-      ICameraDeviceSession::getCaptureRequestMetadataQueue_cb _hidl_cb) override;
+  ScopedAStatus close() override;
 
-  Return<void> getCaptureResultMetadataQueue(
-      ICameraDeviceSession::getCaptureResultMetadataQueue_cb _hidl_cb) override;
+  ScopedAStatus configureStreams(const StreamConfiguration&,
+                                 std::vector<HalStream>*) override;
 
-  Return<void> processCaptureRequest_3_4(
-      const hidl_vec<V3_4::CaptureRequest>& requests,
-      const hidl_vec<BufferCache>& cachesToRemove,
-      processCaptureRequest_3_4_cb _hidl_cb) override;
+  ScopedAStatus constructDefaultRequestSettings(
+      RequestTemplate in_type, CameraMetadata* _aidl_return) override;
 
-  Return<void> signalStreamFlush(const hidl_vec<int32_t>& streamIds,
-                                 uint32_t streamConfigCounter) override;
+  ScopedAStatus flush() override;
 
-  Return<void> isReconfigurationRequired(const V3_2::CameraMetadata& oldSessionParams,
-      const V3_2::CameraMetadata& newSessionParams,
-      ICameraDeviceSession::isReconfigurationRequired_cb _hidl_cb) override;
+  ScopedAStatus getCaptureRequestMetadataQueue(
+      ::aidl::android::hardware::common::fmq::MQDescriptor<
+          int8_t, SynchronizedReadWrite>* _aidl_return) override;
 
-  Return<Status> flush() override;
+  ScopedAStatus getCaptureResultMetadataQueue(
+      ::aidl::android::hardware::common::fmq::MQDescriptor<
+          int8_t, SynchronizedReadWrite>* _aidl_return) override;
 
-  Return<void> close() override;
+  ScopedAStatus isReconfigurationRequired(
+      const CameraMetadata& in_oldSessionParams,
+      const CameraMetadata& in_newSessionParams, bool* _aidl_return) override;
 
-  // Legacy methods
-  Return<void> configureStreams(const V3_2::StreamConfiguration&,
-                                configureStreams_cb _hidl_cb) override;
+  ScopedAStatus processCaptureRequest(
+      const std::vector<CaptureRequest>& in_requests,
+      const std::vector<BufferCache>& in_cachesToRemove,
+      int32_t* _aidl_return) override;
 
-  Return<void> configureStreams_3_3(const V3_2::StreamConfiguration&,
-                                    configureStreams_3_3_cb _hidl_cb) override;
+  ScopedAStatus signalStreamFlush(const std::vector<int32_t>& in_streamIds,
+                                  int32_t in_streamConfigCounter) override;
 
-  Return<void> configureStreams_3_4(const V3_4::StreamConfiguration&,
-                                    configureStreams_3_4_cb _hidl_cb) override;
+  ScopedAStatus switchToOffline(
+      const std::vector<int32_t>& in_streamsToKeep,
+      CameraOfflineSessionInfo* out_offlineSessionInfo,
+      std::shared_ptr<ICameraOfflineSession>* _aidl_return) override;
 
-  Return<void> processCaptureRequest(
-      const hidl_vec<V3_2::CaptureRequest>& requests,
-      const hidl_vec<BufferCache>& cachesToRemove,
-      processCaptureRequest_cb _hidl_cb) override;
-  // End of override functions in ICameraDeviceSession
+  ScopedAStatus repeatingRequestEnd(
+      int32_t /*in_frameNumber*/,
+      const std::vector<int32_t>& /*in_streamIds*/) override {
+    return ScopedAStatus::ok();
+  };
 
- protected:
-  HidlCameraDeviceSession() = default;
+  AidlCameraDeviceSession() = default;
 
  private:
   static constexpr uint32_t kRequestMetadataQueueSizeBytes = 1 << 20;  // 1MB
@@ -138,11 +120,11 @@ class HidlCameraDeviceSession : public ICameraDeviceSession {
   // Initialize the latest available gralloc buffer mapper.
   status_t InitializeBufferMapper();
 
-  // Initialize HidlCameraDeviceSession with a CameraDeviceSession.
+  // Initialize AidlCameraDeviceSession with a CameraDeviceSession.
   status_t Initialize(
-      const sp<V3_2::ICameraDeviceCallback>& callback,
+      const std::shared_ptr<ICameraDeviceCallback>& callback,
       std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
-      std::shared_ptr<HidlProfiler> hidl_profiler);
+      std::shared_ptr<AidlProfiler> aidl_profiler);
 
   // Create a metadata queue.
   // If override_size_property contains a valid size, it will create a metadata
@@ -159,7 +141,7 @@ class HidlCameraDeviceSession : public ICameraDeviceSession {
   void ProcessCaptureResult(
       std::unique_ptr<google_camera_hal::CaptureResult> hal_result);
 
-  // Invoked when reciving a message from HAL.
+  // Invoked when receiving a message from HAL.
   void NotifyHalMessage(const google_camera_hal::NotifyMessage& hal_message);
 
   // Invoked when requesting stream buffers from HAL.
@@ -201,9 +183,9 @@ class HidlCameraDeviceSession : public ICameraDeviceSession {
 
   // Assuming callbacks to framework is thread-safe, the shared mutex is only
   // used to protect member variable writing and reading.
-  std::shared_mutex hidl_device_callback_lock_;
-  // Protected by hidl_device_callback_lock_
-  sp<ICameraDeviceCallback> hidl_device_callback_;
+  std::shared_mutex aidl_device_callback_lock_;
+  // Protected by aidl_device_callback_lock_
+  std::shared_ptr<ICameraDeviceCallback> aidl_device_callback_;
 
   sp<android::hardware::graphics::mapper::V2_0::IMapper> buffer_mapper_v2_;
   sp<android::hardware::graphics::mapper::V3_0::IMapper> buffer_mapper_v3_;
@@ -227,14 +209,13 @@ class HidlCameraDeviceSession : public ICameraDeviceSession {
   // Must be protected by pending_first_frame_buffers_mutex_
   size_t num_pending_first_frame_buffers_ = 0;
 
-  std::shared_ptr<HidlProfiler> hidl_profiler_;
+  std::shared_ptr<AidlProfiler> aidl_profiler_;
 };
 
 }  // namespace implementation
-}  // namespace V3_7
 }  // namespace device
 }  // namespace camera
 }  // namespace hardware
 }  // namespace android
 
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_SESSION_H_
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_DEVICE_SESSION_H_
diff --git a/common/hal/aidl_service/aidl_camera_provider.cc b/common/hal/aidl_service/aidl_camera_provider.cc
new file mode 100644
index 0000000..7eac3f2
--- /dev/null
+++ b/common/hal/aidl_service/aidl_camera_provider.cc
@@ -0,0 +1,397 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "GCH_AidlCameraProvider"
+//#define LOG_NDEBUG 0
+#include "aidl_camera_provider.h"
+
+#include <log/log.h>
+
+#include <regex>
+
+#include "aidl_camera_device.h"
+#include "aidl_utils.h"
+#include "camera_device.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace provider {
+namespace implementation {
+
+namespace aidl_utils = ::android::hardware::camera::implementation::aidl_utils;
+
+using aidl::android::hardware::camera::common::CameraDeviceStatus;
+using aidl::android::hardware::camera::common::Status;
+using aidl::android::hardware::camera::common::TorchModeStatus;
+using aidl::android::hardware::camera::common::VendorTagSection;
+using ::android::google_camera_hal::CameraDevice;
+
+const std::string AidlCameraProvider::kProviderName = "internal";
+// "device@<version>/internal/<id>"
+const std::regex AidlCameraProvider::kDeviceNameRegex(
+    "device@([0-9]+\\.[0-9]+)/internal/(.+)");
+
+std::shared_ptr<AidlCameraProvider> AidlCameraProvider::Create() {
+  std::shared_ptr<AidlCameraProvider> provider =
+      ndk::SharedRefBase::make<AidlCameraProvider>();
+
+  status_t res = provider->Initialize();
+  if (res != OK) {
+    ALOGE("%s: Initializing AidlCameraProvider failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return nullptr;
+  }
+
+  return provider;
+}
+
+status_t AidlCameraProvider::Initialize() {
+  google_camera_provider_ = CameraProvider::Create();
+  if (google_camera_provider_ == nullptr) {
+    ALOGE("%s: Creating CameraProvider failed.", __FUNCTION__);
+    return NO_INIT;
+  }
+
+  camera_provider_callback_ = {
+      .camera_device_status_change = google_camera_hal::CameraDeviceStatusChangeFunc(
+          [this](std::string camera_id,
+                 google_camera_hal::CameraDeviceStatus new_status) {
+            if (callbacks_ == nullptr) {
+              ALOGE("%s: callbacks_ is null", __FUNCTION__);
+              return;
+            }
+            CameraDeviceStatus aidl_camera_device_status;
+            status_t res = aidl_utils::ConvertToAidlCameraDeviceStatus(
+                new_status, &aidl_camera_device_status);
+            if (res != OK) {
+              ALOGE(
+                  "%s: Converting to aidl camera device status failed: %s(%d)",
+                  __FUNCTION__, strerror(-res), res);
+              return;
+            }
+
+            std::unique_lock<std::mutex> lock(callbacks_lock_);
+            auto aidl_res = callbacks_->cameraDeviceStatusChange(
+                "device@" +
+                    device::implementation::AidlCameraDevice::kDeviceVersion +
+                    "/" + kProviderName + "/" + camera_id,
+                aidl_camera_device_status);
+            if (!aidl_res.isOk()) {
+              ALOGE("%s: device status change transaction error: %s",
+                    __FUNCTION__, aidl_res.getMessage());
+              return;
+            }
+          }),
+      .physical_camera_device_status_change =
+          google_camera_hal::PhysicalCameraDeviceStatusChangeFunc(
+              [this](std::string camera_id, std::string physical_camera_id,
+                     google_camera_hal::CameraDeviceStatus new_status) {
+                if (callbacks_ == nullptr) {
+                  ALOGE("%s: callbacks_ is null", __FUNCTION__);
+                  return;
+                }
+                /*auto castResult =
+                    provider::V2_6::ICameraProviderCallback::castFrom(callbacks_);
+                if (!castResult.isOk()) {
+                  ALOGE("%s: callbacks_ cannot be casted to version 2.6",
+                        __FUNCTION__);
+                  return;
+                }
+                sp<provider::V2_6::ICameraProviderCallback> callbacks_2_6_ =
+                    castResult;
+                if (callbacks_2_6_ == nullptr) {
+                  ALOGE("%s: callbacks_2_6_ is null", __FUNCTION__);
+                  return;
+                }*/
+
+                CameraDeviceStatus aidl_camera_device_status;
+                status_t res = aidl_utils::ConvertToAidlCameraDeviceStatus(
+                    new_status, &aidl_camera_device_status);
+                if (res != OK) {
+                  ALOGE(
+                      "%s: Converting to aidl camera device status failed: "
+                      "%s(%d)",
+                      __FUNCTION__, strerror(-res), res);
+                  return;
+                }
+
+                std::unique_lock<std::mutex> lock(callbacks_lock_);
+                auto aidl_res = callbacks_->physicalCameraDeviceStatusChange(
+                    "device@" +
+                        device::implementation::AidlCameraDevice::kDeviceVersion +
+                        "/" + kProviderName + "/" + camera_id,
+                    physical_camera_id, aidl_camera_device_status);
+                if (!aidl_res.isOk()) {
+                  ALOGE(
+                      "%s: physical camera status change transaction error: %s",
+                      __FUNCTION__, aidl_res.getMessage());
+                  return;
+                }
+              }),
+      .torch_mode_status_change = google_camera_hal::TorchModeStatusChangeFunc(
+          [this](std::string camera_id,
+                 google_camera_hal::TorchModeStatus new_status) {
+            if (callbacks_ == nullptr) {
+              ALOGE("%s: callbacks_ is null", __FUNCTION__);
+              return;
+            }
+
+            TorchModeStatus aidl_torch_status;
+            status_t res = aidl_utils::ConvertToAidlTorchModeStatus(
+                new_status, &aidl_torch_status);
+            if (res != OK) {
+              ALOGE("%s: Converting to aidl torch status failed: %s(%d)",
+                    __FUNCTION__, strerror(-res), res);
+              return;
+            }
+
+            std::unique_lock<std::mutex> lock(callbacks_lock_);
+            auto aidl_res = callbacks_->torchModeStatusChange(
+                "device@" +
+                    device::implementation::AidlCameraDevice::kDeviceVersion +
+                    "/" + kProviderName + "/" + camera_id,
+                aidl_torch_status);
+            if (!aidl_res.isOk()) {
+              ALOGE("%s: torch status change transaction error: %s",
+                    __FUNCTION__, aidl_res.getMessage());
+              return;
+            }
+          }),
+  };
+
+  google_camera_provider_->SetCallback(&camera_provider_callback_);
+  // purge pending malloc pages after initialization
+  mallopt(M_PURGE, 0);
+  return OK;
+}
+
+ScopedAStatus AidlCameraProvider::setCallback(
+    const std::shared_ptr<ICameraProviderCallback>& callback) {
+  if (callback == nullptr) {
+    ALOGE("AidlCameraProvider::setCallback() called with nullptr");
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+
+  bool first_time = false;
+  {
+    std::unique_lock<std::mutex> lock(callbacks_lock_);
+    first_time = callbacks_ == nullptr;
+    callbacks_ = callback;
+  }
+  google_camera_provider_->TriggerDeferredCallbacks();
+#ifdef __ANDROID_APEX__
+  if (first_time) {
+    std::string ready_property_name = "vendor.camera.hal.ready.count";
+    int ready_count = property_get_int32(ready_property_name.c_str(), 0);
+    property_set(ready_property_name.c_str(),
+                 std::to_string(++ready_count).c_str());
+    ALOGI("AidlCameraProvider::setCallback() first time ready count: %d ",
+          ready_count);
+  }
+#endif
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraProvider::getVendorTags(
+    std::vector<VendorTagSection>* vts) {
+  if (vts == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  vts->clear();
+  std::vector<google_camera_hal::VendorTagSection> hal_vendor_tag_sections;
+
+  status_t res =
+      google_camera_provider_->GetVendorTags(&hal_vendor_tag_sections);
+  if (res != OK) {
+    ALOGE("%s: Getting vendor tags failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  res = aidl_utils::ConvertToAidlVendorTagSections(hal_vendor_tag_sections, vts);
+  if (res != OK) {
+    ALOGE("%s: Converting to aidl vendor tags failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraProvider::getCameraIdList(
+    std::vector<std::string>* camera_ids_ret) {
+  if (camera_ids_ret == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  camera_ids_ret->clear();
+  std::vector<uint32_t> camera_ids;
+  status_t res = google_camera_provider_->GetCameraIdList(&camera_ids);
+  if (res != OK) {
+    ALOGE("%s: Getting camera ID list failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+
+  camera_ids_ret->resize(camera_ids.size());
+  for (uint32_t i = 0; i < camera_ids_ret->size(); i++) {
+    // camera ID is in the form of "device@<major>.<minor>/<type>/<id>"
+    (*camera_ids_ret)[i] =
+        "device@" + device::implementation::AidlCameraDevice::kDeviceVersion +
+        "/" + kProviderName + "/" + std::to_string(camera_ids[i]);
+  }
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraProvider::getConcurrentCameraIds(
+    std::vector<ConcurrentCameraIdCombination>* aidl_camera_id_combinations) {
+  if (aidl_camera_id_combinations == nullptr) {
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+  aidl_camera_id_combinations->clear();
+  std::vector<std::unordered_set<uint32_t>> camera_id_combinations;
+  status_t res = google_camera_provider_->GetConcurrentStreamingCameraIds(
+      &camera_id_combinations);
+  if (res != OK) {
+    ALOGE(
+        "%s: Getting the combinations of concurrent streaming camera ids "
+        "failed: %s(%d)",
+        __FUNCTION__, strerror(-res), res);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  aidl_camera_id_combinations->resize(camera_id_combinations.size());
+  int i = 0;
+  for (auto& combination : camera_id_combinations) {
+    std::vector<std::string> aidl_combination(combination.size());
+    int c = 0;
+    for (auto& camera_id : combination) {
+      aidl_combination[c] = std::to_string(camera_id);
+      c++;
+    }
+    (*aidl_camera_id_combinations)[i].combination = aidl_combination;
+    i++;
+  }
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraProvider::isConcurrentStreamCombinationSupported(
+    const std::vector<CameraIdAndStreamCombination>& configs, bool* supported) {
+  *supported = false;
+  std::vector<google_camera_hal::CameraIdAndStreamConfiguration>
+      devices_stream_configs(configs.size());
+  status_t res = OK;
+  size_t c = 0;
+  for (auto& config : configs) {
+    res = aidl_utils::ConvertToHalStreamConfig(
+        config.streamConfiguration,
+        &devices_stream_configs[c].stream_configuration);
+    if (res != OK) {
+      ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::INTERNAL_ERROR));
+    }
+    uint32_t camera_id = atoi(config.cameraId.c_str());
+    devices_stream_configs[c].camera_id = camera_id;
+    c++;
+  }
+  res = google_camera_provider_->IsConcurrentStreamCombinationSupported(
+      devices_stream_configs, supported);
+  if (res != OK) {
+    ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  return ScopedAStatus::ok();
+}
+
+bool AidlCameraProvider::ParseDeviceName(const std::string& device_name,
+                                         std::string* device_version,
+                                         std::string* camera_id) {
+  std::string device_name_std(device_name.c_str());
+  std::smatch sm;
+
+  if (std::regex_match(device_name_std, sm,
+                       AidlCameraProvider::kDeviceNameRegex)) {
+    if (device_version != nullptr) {
+      *device_version = sm[1];
+    }
+    if (camera_id != nullptr) {
+      *camera_id = sm[2];
+    }
+    return true;
+  }
+  return false;
+}
+
+ScopedAStatus AidlCameraProvider::getCameraDeviceInterface(
+    const std::string& camera_device_name,
+    std::shared_ptr<ICameraDevice>* device) {
+  std::unique_ptr<CameraDevice> google_camera_device;
+  if (device == nullptr) {
+    ALOGE("%s: device is nullptr. ", __FUNCTION__);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+
+  // Parse camera_device_name.
+  std::string camera_id, device_version;
+
+  bool match = ParseDeviceName(camera_device_name, &device_version, &camera_id);
+  if (!match) {
+    ALOGE("%s: Device name parse fail. ", __FUNCTION__);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+  }
+
+  status_t res = google_camera_provider_->CreateCameraDevice(
+      atoi(camera_id.c_str()), &google_camera_device);
+  if (res != OK) {
+    ALOGE("%s: Creating CameraDevice failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return aidl_utils::ConvertToAidlReturn(res);
+  }
+
+  *device = device::implementation::AidlCameraDevice::Create(
+      std::move(google_camera_device));
+  if (*device == nullptr) {
+    ALOGE("%s: Creating AidlCameraDevice failed", __FUNCTION__);
+    return ScopedAStatus::fromServiceSpecificError(
+        static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+  return ScopedAStatus::ok();
+}
+
+ScopedAStatus AidlCameraProvider::notifyDeviceStateChange(int64_t new_state) {
+  google_camera_hal::DeviceState device_state =
+      google_camera_hal::DeviceState::kNormal;
+  ::android::hardware::camera::implementation::aidl_utils::ConvertToHalDeviceState(
+      new_state, device_state);
+  google_camera_provider_->NotifyDeviceStateChange(device_state);
+  return ScopedAStatus::ok();
+}
+
+}  // namespace implementation
+}  // namespace provider
+}  // namespace camera
+}  // namespace hardware
+}  // namespace android
diff --git a/common/hal/aidl_service/aidl_camera_provider.h b/common/hal/aidl_service/aidl_camera_provider.h
new file mode 100644
index 0000000..7cd5bde
--- /dev/null
+++ b/common/hal/aidl_service/aidl_camera_provider.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_PROVIDER_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_PROVIDER_H_
+
+#include <aidl/android/hardware/camera/provider/BnCameraProvider.h>
+#include <aidl/android/hardware/camera/provider/ICameraProviderCallback.h>
+
+#include <regex>
+
+#include "camera_provider.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace provider {
+namespace implementation {
+
+using aidl::android::hardware::camera::common::VendorTagSection;
+using aidl::android::hardware::camera::device::ICameraDevice;
+using aidl::android::hardware::camera::provider::BnCameraProvider;
+using aidl::android::hardware::camera::provider::CameraIdAndStreamCombination;
+using aidl::android::hardware::camera::provider::ConcurrentCameraIdCombination;
+using aidl::android::hardware::camera::provider::ICameraProviderCallback;
+
+using ::android::google_camera_hal::CameraProvider;
+using ndk::ScopedAStatus;
+
+// AidlCameraProvider implements the AIDL camera provider interface,
+// ICameraProvider, to enumerate the available individual camera devices
+// in the system, and provide updates about changes to device status.
+class AidlCameraProvider : public BnCameraProvider {
+ public:
+  static const std::string kProviderName;
+  static std::shared_ptr<AidlCameraProvider> Create();
+  virtual ~AidlCameraProvider() = default;
+
+  // Override functions in ICameraProvider.
+
+  ScopedAStatus setCallback(
+      const std::shared_ptr<ICameraProviderCallback>& callback) override;
+
+  ScopedAStatus getVendorTags(std::vector<VendorTagSection>* vts) override;
+
+  ScopedAStatus getCameraIdList(std::vector<std::string>* camera_ids) override;
+
+  ScopedAStatus getCameraDeviceInterface(
+      const std::string& in_cameraDeviceName,
+      std::shared_ptr<ICameraDevice>* device) override;
+
+  ScopedAStatus notifyDeviceStateChange(int64_t in_deviceState) override;
+
+  ScopedAStatus getConcurrentCameraIds(
+      std::vector<ConcurrentCameraIdCombination>* concurrent_camera_ids) override;
+
+  ScopedAStatus isConcurrentStreamCombinationSupported(
+      const std::vector<CameraIdAndStreamCombination>& in_configs,
+      bool* support) override;
+
+  // End of override functions in ICameraProvider.
+  AidlCameraProvider() = default;
+
+ private:
+  static const std::regex kDeviceNameRegex;
+
+  status_t Initialize();
+
+  // Parse device version and camera ID.
+  bool ParseDeviceName(const std::string& device_name,
+                       std::string* device_version, std::string* camera_id);
+
+  std::mutex callbacks_lock_;
+  std::shared_ptr<ICameraProviderCallback> callbacks_;
+
+  std::unique_ptr<CameraProvider> google_camera_provider_;
+  google_camera_hal::CameraProviderCallback camera_provider_callback_;
+};
+
+}  // namespace implementation
+}  // namespace provider
+}  // namespace camera
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_CAMERA_PROVIDER_H_
diff --git a/common/hal/hidl_service/hidl_profiler.cc b/common/hal/aidl_service/aidl_profiler.cc
index 7bb8027..5c7e90d 100644
--- a/common/hal/hidl_service/hidl_profiler.cc
+++ b/common/hal/aidl_service/aidl_profiler.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,9 @@
  */
 
 //#define LOG_NDEBUG 0
-#define LOG_TAG "GCH_HidlProfiler"
+#define LOG_TAG "GCH_AidlProfiler"
 
-#include "hidl_profiler.h"
+#include "aidl_profiler.h"
 
 #include <log/log.h>
 
@@ -46,25 +46,31 @@ constexpr char kHalTotal[] = "HAL Total";
 constexpr char kIdleString[] = "<-- IDLE -->";
 constexpr char kOverall[] = "Overall";
 
-class HidlProfilerImpl : public HidlProfiler {
+class AidlProfilerImpl : public AidlProfiler {
  public:
-  HidlProfilerImpl(uint32_t camera_id, int32_t latency_flag, int32_t fps_flag)
+  AidlProfilerImpl(uint32_t camera_id, int32_t latency_flag, int32_t fps_flag)
       : camera_id_string_("Cam" + std::to_string(camera_id)),
         camera_id_(camera_id),
         latency_flag_(latency_flag),
         fps_flag_(fps_flag) {
   }
 
-  std::unique_ptr<HidlScopedProfiler> MakeScopedProfiler(
-      ScopedType type) override {
+  std::unique_ptr<AidlScopedProfiler> MakeScopedProfiler(
+      ScopedType type,
+      std::unique_ptr<google::camera_common::Profiler> custom_latency_profiler,
+      std::unique_ptr<google::camera_common::Profiler> custom_fps_profiler)
+      override {
     std::lock_guard lock(api_mutex_);
-
     if (type == ScopedType::kConfigureStream && fps_profiler_ == nullptr) {
-      fps_profiler_ = CreateFpsProfiler();
+      if (SetFpsProfiler(std::move(custom_fps_profiler)) == false) {
+        fps_profiler_ = CreateFpsProfiler();
+      }
     }
 
     if (latency_profiler_ == nullptr) {
-      latency_profiler_ = CreateLatencyProfiler();
+      if (SetLatencyProfiler(std::move(custom_latency_profiler)) == false) {
+        latency_profiler_ = CreateLatencyProfiler();
+      }
       if (latency_profiler_ != nullptr) {
         has_camera_open_ = false;
         config_count_ = 0;
@@ -105,7 +111,7 @@ class HidlProfilerImpl : public HidlProfiler {
         ALOGE("%s: Unknown type %d", __FUNCTION__, type);
         return nullptr;
     }
-    return std::make_unique<HidlScopedProfiler>(
+    return std::make_unique<AidlScopedProfiler>(
         latency_profiler_, name, id, [this, type]() {
           std::lock_guard lock(api_mutex_);
           if (type == ScopedType::kClose) {
@@ -141,33 +147,6 @@ class HidlProfilerImpl : public HidlProfiler {
     }
   }
 
-  void SetLatencyProfiler(std::unique_ptr<Profiler> profiler) override {
-    if (profiler == nullptr || latency_profiler_ == nullptr) {
-      return;
-    }
-    latency_profiler_ = std::move(profiler);
-    if (latency_profiler_ != nullptr) {
-      latency_profiler_->SetDumpFilePrefix(
-          "/data/vendor/camera/profiler/hidl_open_close_");
-      latency_profiler_->Start(kOverall, Profiler::kInvalidRequestId);
-      has_camera_open_ = false;
-      config_count_ = 0;
-      flush_count_ = 0;
-      idle_count_ = 0;
-    }
-  }
-
-  void SetFpsProfiler(std::unique_ptr<Profiler> profiler) override {
-    if (profiler == nullptr || fps_profiler_ == nullptr) {
-      return;
-    }
-    fps_profiler_ = std::move(profiler);
-    if (fps_profiler_ != nullptr) {
-      fps_profiler_->SetDumpFilePrefix(
-          "/data/vendor/camera/profiler/hidl_fps_");
-    }
-  }
-
  private:
   std::shared_ptr<Profiler> CreateLatencyProfiler() {
     if (latency_flag_ == Profiler::SetPropFlag::kDisable) {
@@ -179,7 +158,7 @@ class HidlProfilerImpl : public HidlProfiler {
       return nullptr;
     }
     profiler->SetDumpFilePrefix(
-        "/data/vendor/camera/profiler/hidl_open_close_");
+        "/data/vendor/camera/profiler/aidl_open_close_");
     profiler->Start(kOverall, Profiler::kInvalidRequestId);
     return profiler;
   }
@@ -193,7 +172,7 @@ class HidlProfilerImpl : public HidlProfiler {
       ALOGE("%s: Failed to create profiler", __FUNCTION__);
       return nullptr;
     }
-    profiler->SetDumpFilePrefix("/data/vendor/camera/profiler/hidl_fps_");
+    profiler->SetDumpFilePrefix("/data/vendor/camera/profiler/aidl_fps_");
     return profiler;
   }
 
@@ -226,6 +205,33 @@ class HidlProfilerImpl : public HidlProfiler {
     return fps_flag_;
   }
 
+  bool SetLatencyProfiler(std::unique_ptr<Profiler> profiler) {
+    if (profiler == nullptr) {
+      return false;
+    }
+    latency_profiler_ = std::move(profiler);
+    if (latency_profiler_ != nullptr) {
+      latency_profiler_->SetDumpFilePrefix(
+          "/data/vendor/camera/profiler/aidl_open_close_");
+      latency_profiler_->Start(kOverall, Profiler::kInvalidRequestId);
+      return true;
+    }
+    return false;
+  }
+
+  bool SetFpsProfiler(std::unique_ptr<Profiler> profiler) {
+    if (profiler == nullptr) {
+      return false;
+    }
+    fps_profiler_ = std::move(profiler);
+    if (fps_profiler_ != nullptr) {
+      fps_profiler_->SetDumpFilePrefix(
+          "/data/vendor/camera/profiler/aidl_fps_");
+      return true;
+    }
+    return false;
+  }
+
   const std::string camera_id_string_;
   const uint32_t camera_id_;
   const int32_t latency_flag_;
@@ -242,27 +248,16 @@ class HidlProfilerImpl : public HidlProfiler {
   uint8_t idle_count_;
 };
 
-class HidlProfilerMock : public HidlProfiler {
-  std::unique_ptr<HidlScopedProfiler> MakeScopedProfiler(ScopedType) override {
+class AidlProfilerMock : public AidlProfiler {
+  std::unique_ptr<AidlScopedProfiler> MakeScopedProfiler(
+      ScopedType, std::unique_ptr<google::camera_common::Profiler>,
+      std::unique_ptr<google::camera_common::Profiler>) override {
     return nullptr;
   }
 
-  void FirstFrameStart() override {
-  }
-
-  void FirstFrameEnd() override {
-  }
-
-  void ProfileFrameRate(const std::string&) override {
-  }
-
-  void SetLatencyProfiler(
-      std::unique_ptr<google::camera_common::Profiler> /* profiler */) override {
-  }
-
-  void SetFpsProfiler(
-      std::unique_ptr<google::camera_common::Profiler> /* profiler */) override {
-  }
+  void FirstFrameStart() override{};
+  void FirstFrameEnd() override{};
+  void ProfileFrameRate(const std::string&) override{};
 
   uint32_t GetCameraId() const override {
     return 0;
@@ -277,14 +272,14 @@ class HidlProfilerMock : public HidlProfiler {
 
 }  // anonymous namespace
 
-std::shared_ptr<HidlProfiler> HidlProfiler::Create(uint32_t camera_id) {
+std::shared_ptr<AidlProfiler> AidlProfiler::Create(uint32_t camera_id) {
   int32_t latency_flag = property_get_int32(
       kPropKeyProfileOpenClose, Profiler::SetPropFlag::kCustomProfiler);
   int32_t fps_flag = property_get_int32(kPropKeyProfileFps,
                                         Profiler::SetPropFlag::kCustomProfiler);
   if (latency_flag == Profiler::SetPropFlag::kDisable &&
       fps_flag == Profiler::SetPropFlag::kDisable) {
-    return std::make_shared<HidlProfilerMock>();
+    return std::make_shared<AidlProfilerMock>();
   }
   // Use stopwatch flag to print result.
   if ((latency_flag & Profiler::SetPropFlag::kPrintBit) != 0) {
@@ -295,10 +290,10 @@ std::shared_ptr<HidlProfiler> HidlProfiler::Create(uint32_t camera_id) {
     fps_flag |= Profiler::SetPropFlag::kPrintFpsPerIntervalBit;
     fps_flag &= ~Profiler::SetPropFlag::kPrintBit;
   }
-  return std::make_shared<HidlProfilerImpl>(camera_id, latency_flag, fps_flag);
+  return std::make_shared<AidlProfilerImpl>(camera_id, latency_flag, fps_flag);
 }
 
-HidlScopedProfiler::HidlScopedProfiler(std::shared_ptr<Profiler> profiler,
+AidlScopedProfiler::AidlScopedProfiler(std::shared_ptr<Profiler> profiler,
                                        const std::string name, int id,
                                        std::function<void()> end_callback)
     : profiler_(profiler),
@@ -309,7 +304,7 @@ HidlScopedProfiler::HidlScopedProfiler(std::shared_ptr<Profiler> profiler,
   profiler_->Start(kHalTotal, Profiler::kInvalidRequestId);
 }
 
-HidlScopedProfiler::~HidlScopedProfiler() {
+AidlScopedProfiler::~AidlScopedProfiler() {
   profiler_->End(kHalTotal, Profiler::kInvalidRequestId);
   profiler_->End(name_, id_);
   if (end_callback_) {
diff --git a/common/hal/hidl_service/hidl_profiler.h b/common/hal/aidl_service/aidl_profiler.h
index 131a0c3..1491056 100644
--- a/common/hal/hidl_service/hidl_profiler.h
+++ b/common/hal/aidl_service/aidl_profiler.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_PROFILER_H_
-#define HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_PROFILER_H_
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_PROFILER_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_PROFILER_H_
 
 #include <memory>
 
@@ -26,13 +26,13 @@ namespace hardware {
 namespace camera {
 namespace implementation {
 
-class HidlScopedProfiler {
+class AidlScopedProfiler {
  public:
-  HidlScopedProfiler(std::shared_ptr<google::camera_common::Profiler> profiler,
+  AidlScopedProfiler(std::shared_ptr<google::camera_common::Profiler> profiler,
                      const std::string name, int id,
                      std::function<void()> end_callback);
 
-  ~HidlScopedProfiler();
+  ~AidlScopedProfiler();
 
  private:
   std::shared_ptr<google::camera_common::Profiler> profiler_;
@@ -41,7 +41,7 @@ class HidlScopedProfiler {
   std::function<void()> end_callback_;
 };
 
-class HidlProfiler {
+class AidlProfiler {
  public:
   enum class ScopedType {
     kOpen,
@@ -49,13 +49,15 @@ class HidlProfiler {
     kFlush,
     kClose,
   };
-  virtual ~HidlProfiler() = default;
+  virtual ~AidlProfiler() = default;
 
-  static std::shared_ptr<HidlProfiler> Create(uint32_t camera_id);
+  static std::shared_ptr<AidlProfiler> Create(uint32_t camera_id);
 
   // Make a ScopedProfiler for given type.
-  virtual std::unique_ptr<HidlScopedProfiler> MakeScopedProfiler(
-      ScopedType type) = 0;
+  virtual std::unique_ptr<AidlScopedProfiler> MakeScopedProfiler(
+      ScopedType type,
+      std::unique_ptr<google::camera_common::Profiler> custom_latency_profiler,
+      std::unique_ptr<google::camera_common::Profiler> custom_fps_profiler) = 0;
 
   // Call when first frame is requested.
   virtual void FirstFrameStart() = 0;
@@ -66,20 +68,12 @@ class HidlProfiler {
   // Call to profile frame rate for each stream.
   virtual void ProfileFrameRate(const std::string& name) = 0;
 
-  // Give a customized latency profiler so that client side can intercept various calls.
-  virtual void SetLatencyProfiler(
-      std::unique_ptr<google::camera_common::Profiler> profiler) = 0;
-
-  // Give a customized fps profiler so that client side can intercept various calls.
-  virtual void SetFpsProfiler(
-      std::unique_ptr<google::camera_common::Profiler> profiler) = 0;
-
   virtual uint32_t GetCameraId() const = 0;
   virtual int32_t GetLatencyFlag() const = 0;
   virtual int32_t GetFpsFlag() const = 0;
 
  protected:
-  HidlProfiler() = default;
+  AidlProfiler() = default;
 };
 
 }  // namespace implementation
@@ -87,4 +81,4 @@ class HidlProfiler {
 }  // namespace hardware
 }  // namespace android
 
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_PROFILER_H_
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_PROFILER_H_
diff --git a/common/hal/hidl_service/service.cc b/common/hal/aidl_service/aidl_service.cc
index 630869e..91f52b1 100644
--- a/common/hal/hidl_service/service.cc
+++ b/common/hal/aidl_service/aidl_service.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,21 +20,23 @@
 #define LOG_TAG "android.hardware.pixel.camera.provider@2.7-service"
 #endif
 
-#include <android/hardware/camera/provider/2.7/ICameraProvider.h>
+#include <aidl/android/hardware/camera/provider/ICameraProvider.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
 #include <apex_update_listener.h>
 #include <binder/ProcessState.h>
-#include <cinttypes>
 #include <cutils/properties.h>
-#include <hidl/HidlLazyUtils.h>
 #include <hidl/HidlTransportSupport.h>
 #include <malloc.h>
 #include <utils/Errors.h>
 
-#include "hidl_camera_build_version.h"
-#include "hidl_camera_provider.h"
+#include <cinttypes>
+
+#include "aidl_camera_build_version.h"
+#include "aidl_camera_provider.h"
 
-using ::android::hardware::camera::provider::V2_7::ICameraProvider;
-using ::android::hardware::camera::provider::V2_7::implementation::HidlCameraProvider;
+using aidl::android::hardware::camera::provider::ICameraProvider;
+using ::android::hardware::camera::provider::implementation::AidlCameraProvider;
 
 #ifdef LAZY_SERVICE
 const bool kLazyService = true;
@@ -42,6 +44,8 @@ const bool kLazyService = true;
 const bool kLazyService = false;
 #endif
 
+const std::string kProviderInstance = "/internal/0";
+
 int main() {
   ALOGI("Google camera provider service is starting.");
   // The camera HAL may communicate to other vendor components via
@@ -51,6 +55,11 @@ int main() {
   android::hardware::configureRpcThreadpool(/*maxThreads=*/6,
                                             /*callerWillJoin=*/true);
 
+  // Don't depend on vndbinder setting up threads in case we stop using them
+  // some day
+  ABinderProcess_setThreadPoolMaxThreadCount(6);
+  ABinderProcess_startThreadPool();
+
 #ifdef __ANDROID_APEX__
   int start_count = property_get_int32("vendor.camera.hal.start.count", 0);
   property_set("vendor.camera.hal.start.count",
@@ -72,25 +81,27 @@ int main() {
   ALOGI("Not using ApexUpdateListener since not running in an apex.");
 #endif
 
-  android::sp<ICameraProvider> camera_provider = HidlCameraProvider::Create();
+  std::shared_ptr<ICameraProvider> camera_provider =
+      AidlCameraProvider::Create();
   if (camera_provider == nullptr) {
     return android::NO_INIT;
   }
+  std::string instance =
+      std::string() + AidlCameraProvider::descriptor + kProviderInstance;
   if (kLazyService) {
-    android::hardware::LazyServiceRegistrar& lazy_registrar =
-        android::hardware::LazyServiceRegistrar::getInstance();
-    if (lazy_registrar.registerService(camera_provider, "internal/0") !=
-        android::OK) {
-      ALOGE("Cannot register Google camera provider lazy service");
+    if (AServiceManager_registerLazyService(camera_provider->asBinder().get(),
+                                            instance.c_str()) != STATUS_OK) {
+      ALOGE("Cannot register AIDL Google camera provider lazy service");
       return android::NO_INIT;
     }
   } else {
-    if (camera_provider->registerAsService("internal/0") != android::OK) {
-      ALOGE("Cannot register Google camera provider service");
+    if (AServiceManager_addService(camera_provider->asBinder().get(),
+                                   instance.c_str()) != STATUS_OK) {
+      ALOGE("Cannot register AIDL Google camera provider service");
       return android::NO_INIT;
     }
   }
-  android::hardware::joinRpcThreadpool();
+  ABinderProcess_joinThreadPool();
 
   // In normal operation, the threadpool should never return.
   return EXIT_FAILURE;
diff --git a/common/hal/hidl_service/hidl_utils.cc b/common/hal/aidl_service/aidl_utils.cc
index 1b39958..b5a4028 100644
--- a/common/hal/hidl_service/hidl_utils.cc
+++ b/common/hal/aidl_service/aidl_utils.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,55 +14,80 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "GCH_HidlUtils"
+#define LOG_TAG "GCH_AidlUtils"
 //#define LOG_NDEBUG 0
+#include "aidl_utils.h"
+
+#include <aidlcommonsupport/NativeHandle.h>
 #include <log/log.h>
+
 #include <regex>
 
-#include "hidl_camera_device.h"
-#include "hidl_utils.h"
+#include "aidl_camera_device.h"
+#include "aidl_camera_provider.h"
 
 namespace android {
 namespace hardware {
 namespace camera {
 namespace implementation {
-namespace hidl_utils {
-
-using ::android::hardware::camera::device::V3_2::ErrorCode;
-using ::android::hardware::camera::device::V3_2::ErrorMsg;
-using ::android::hardware::camera::device::V3_2::MsgType;
-using ::android::hardware::camera::device::V3_2::ShutterMsg;
-using ::android::hardware::camera::device::V3_7::implementation::HidlCameraDevice;
-using android::hardware::camera::metadata::V3_6::
-    CameraMetadataEnumAndroidSensorPixelMode;
-using ::android::hardware::camera::provider::V2_7::implementation::HidlCameraProvider;
-
-status_t ConvertToHidlVendorTagType(
+namespace aidl_utils {
+
+using AidlCameraProvider = provider::implementation::AidlCameraProvider;
+using AidlCameraDevice = device::implementation::AidlCameraDevice;
+using AidlStatus = aidl::android::hardware::camera::common::Status;
+
+ScopedAStatus ConvertToAidlReturn(status_t hal_status) {
+  switch (hal_status) {
+    case OK:
+      return ScopedAStatus::ok();
+    case BAD_VALUE:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::ILLEGAL_ARGUMENT));
+    case -EBUSY:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::CAMERA_IN_USE));
+    case -EUSERS:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::MAX_CAMERAS_IN_USE));
+    case UNKNOWN_TRANSACTION:
+    case INVALID_OPERATION:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::OPERATION_NOT_SUPPORTED));
+    case DEAD_OBJECT:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::CAMERA_DISCONNECTED));
+    default:
+      return ScopedAStatus::fromServiceSpecificError(
+          static_cast<int32_t>(Status::INTERNAL_ERROR));
+  }
+}
+
+status_t ConvertToAidlVendorTagType(
     google_camera_hal::CameraMetadataType hal_type,
-    CameraMetadataType* hidl_type) {
-  if (hidl_type == nullptr) {
-    ALOGE("%s: hidl_type is nullptr.", __FUNCTION__);
+    CameraMetadataType* aidl_type) {
+  if (aidl_type == nullptr) {
+    ALOGE("%s: aidl_type is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
   switch (hal_type) {
     case google_camera_hal::CameraMetadataType::kByte:
-      *hidl_type = CameraMetadataType::BYTE;
+      *aidl_type = CameraMetadataType::BYTE;
       break;
     case google_camera_hal::CameraMetadataType::kInt32:
-      *hidl_type = CameraMetadataType::INT32;
+      *aidl_type = CameraMetadataType::INT32;
       break;
     case google_camera_hal::CameraMetadataType::kFloat:
-      *hidl_type = CameraMetadataType::FLOAT;
+      *aidl_type = CameraMetadataType::FLOAT;
       break;
     case google_camera_hal::CameraMetadataType::kInt64:
-      *hidl_type = CameraMetadataType::INT64;
+      *aidl_type = CameraMetadataType::INT64;
       break;
     case google_camera_hal::CameraMetadataType::kDouble:
-      *hidl_type = CameraMetadataType::DOUBLE;
+      *aidl_type = CameraMetadataType::DOUBLE;
       break;
     case google_camera_hal::CameraMetadataType::kRational:
-      *hidl_type = CameraMetadataType::RATIONAL;
+      *aidl_type = CameraMetadataType::RATIONAL;
       break;
     default:
       ALOGE("%s: Unknown google_camera_hal::CameraMetadataType: %u",
@@ -73,86 +98,64 @@ status_t ConvertToHidlVendorTagType(
   return OK;
 }
 
-status_t ConvertToHidlResourceCost(
-    const google_camera_hal::CameraResourceCost& hal_cost,
-    CameraResourceCost* hidl_cost) {
-  if (hidl_cost == nullptr) {
-    ALOGE("%s: hidl_cost is nullptr.", __FUNCTION__);
-    return BAD_VALUE;
-  }
-
-  hidl_cost->resourceCost = hal_cost.resource_cost;
-  hidl_cost->conflictingDevices.resize(hal_cost.conflicting_devices.size());
-
-  for (uint32_t i = 0; i < hal_cost.conflicting_devices.size(); i++) {
-    hidl_cost->conflictingDevices[i] =
-        "device@" + HidlCameraDevice::kDeviceVersion + "/" +
-        HidlCameraProvider::kProviderName + "/" +
-        std::to_string(hal_cost.conflicting_devices[i]);
-  }
-
-  return OK;
-}
-
-status_t ConvertToHidlVendorTagSections(
+status_t ConvertToAidlVendorTagSections(
     const std::vector<google_camera_hal::VendorTagSection>& hal_sections,
-    hidl_vec<VendorTagSection>* hidl_sections) {
-  if (hidl_sections == nullptr) {
-    ALOGE("%s: hidl_sections is nullptr.", __FUNCTION__);
+    std::vector<VendorTagSection>* aidl_sections) {
+  if (aidl_sections == nullptr) {
+    ALOGE("%s: aidl_sections is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hidl_sections->resize(hal_sections.size());
+  aidl_sections->resize(hal_sections.size());
   for (uint32_t i = 0; i < hal_sections.size(); i++) {
-    (*hidl_sections)[i].sectionName = hal_sections[i].section_name;
-    (*hidl_sections)[i].tags.resize(hal_sections[i].tags.size());
+    (*aidl_sections)[i].sectionName = hal_sections[i].section_name;
+    (*aidl_sections)[i].tags.resize(hal_sections[i].tags.size());
 
     for (uint32_t j = 0; j < hal_sections[i].tags.size(); j++) {
-      (*hidl_sections)[i].tags[j].tagId = hal_sections[i].tags[j].tag_id;
-      (*hidl_sections)[i].tags[j].tagName = hal_sections[i].tags[j].tag_name;
+      (*aidl_sections)[i].tags[j].tagId = hal_sections[i].tags[j].tag_id;
+      (*aidl_sections)[i].tags[j].tagName = hal_sections[i].tags[j].tag_name;
       status_t res =
-          ConvertToHidlVendorTagType(hal_sections[i].tags[j].tag_type,
-                                     &(*hidl_sections)[i].tags[j].tagType);
+          ConvertToAidlVendorTagType(hal_sections[i].tags[j].tag_type,
+                                     &(*aidl_sections)[i].tags[j].tagType);
       if (res != OK) {
-        ALOGE("%s: Converting to hidl vendor tag type failed. ", __FUNCTION__);
+        ALOGE("%s: Converting to aidl vendor tag type failed. ", __FUNCTION__);
         return res;
       }
     }
   }
-
   return OK;
 }
 
-Status ConvertToHidlStatus(status_t hal_status) {
-  switch (hal_status) {
-    case OK:
-      return Status::OK;
-    case BAD_VALUE:
-      return Status::ILLEGAL_ARGUMENT;
-    case -EBUSY:
-      return Status::CAMERA_IN_USE;
-    case -EUSERS:
-      return Status::MAX_CAMERAS_IN_USE;
-    case UNKNOWN_TRANSACTION:
-      return Status::METHOD_NOT_SUPPORTED;
-    case INVALID_OPERATION:
-      return Status::OPERATION_NOT_SUPPORTED;
-    case DEAD_OBJECT:
-      return Status::CAMERA_DISCONNECTED;
-    default:
-      return Status::INTERNAL_ERROR;
+status_t ConvertToAidlResourceCost(
+    const google_camera_hal::CameraResourceCost& hal_cost,
+    CameraResourceCost* aidl_cost) {
+  if (aidl_cost == nullptr) {
+    ALOGE("%s: aidl_cost is nullptr.", __FUNCTION__);
+    return BAD_VALUE;
   }
+
+  aidl_cost->resourceCost = hal_cost.resource_cost;
+  aidl_cost->conflictingDevices.resize(hal_cost.conflicting_devices.size());
+
+  for (uint32_t i = 0; i < hal_cost.conflicting_devices.size(); i++) {
+    aidl_cost->conflictingDevices[i] =
+        "device@" + AidlCameraDevice::kDeviceVersion + "/" +
+        AidlCameraProvider::kProviderName + "/" +
+        std::to_string(hal_cost.conflicting_devices[i]);
+  }
+
+  return OK;
 }
 
 status_t ConvertToHalTemplateType(
-    RequestTemplate hidl_template,
+    RequestTemplate aidl_template,
     google_camera_hal::RequestTemplate* hal_template) {
   if (hal_template == nullptr) {
     ALOGE("%s: hal_template is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_template) {
+  switch (aidl_template) {
     case RequestTemplate::PREVIEW:
       *hal_template = google_camera_hal::RequestTemplate::kPreview;
       break;
@@ -172,50 +175,50 @@ status_t ConvertToHalTemplateType(
       *hal_template = google_camera_hal::RequestTemplate::kManual;
       break;
     default:
-      ALOGE("%s: Unknown HIDL RequestTemplate: %u", __FUNCTION__,
-            hidl_template);
+      ALOGE("%s: Unknown AIDL RequestTemplate: %u", __FUNCTION__, aidl_template);
       return BAD_VALUE;
   }
 
   return OK;
 }
 
-status_t ConvertToHidlHalStreamConfig(
+status_t ConvertToAidlHalStreamConfig(
     const std::vector<google_camera_hal::HalStream>& hal_configured_streams,
-    HalStreamConfiguration* hidl_hal_stream_config) {
-  if (hidl_hal_stream_config == nullptr) {
-    ALOGE("%s: hidl_hal_stream_config is nullptr.", __FUNCTION__);
+    std::vector<HalStream>* aidl_hal_streams) {
+  if (aidl_hal_streams == nullptr) {
+    ALOGE("%s: aidl_hal_streams is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hidl_hal_stream_config->streams.resize(hal_configured_streams.size());
+  aidl_hal_streams->resize(hal_configured_streams.size());
 
   for (uint32_t i = 0; i < hal_configured_streams.size(); i++) {
-    hidl_hal_stream_config->streams[i].supportOffline = false;
+    auto& dst = (*aidl_hal_streams)[i];
+    dst.supportOffline = false;
     if (hal_configured_streams[i].is_physical_camera_stream) {
-      hidl_hal_stream_config->streams[i].v3_4.physicalCameraId =
+      dst.physicalCameraId =
           std::to_string(hal_configured_streams[i].physical_camera_id);
     }
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.overrideDataSpace =
-        hal_configured_streams[i].override_data_space;
+    dst.overrideDataSpace =
+        static_cast<aidl::android::hardware::graphics::common::Dataspace>(
+            hal_configured_streams[i].override_data_space);
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.v3_2.id =
-        hal_configured_streams[i].id;
+    dst.id = hal_configured_streams[i].id;
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.v3_2.overrideFormat =
-        (::android::hardware::graphics::common::V1_0::PixelFormat)
-            hal_configured_streams[i]
-                .override_format;
+    dst.overrideFormat =
+        static_cast<aidl::android::hardware::graphics::common::PixelFormat>(
+            hal_configured_streams[i].override_format);
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.v3_2.producerUsage =
-        hal_configured_streams[i].producer_usage;
+    dst.producerUsage =
+        static_cast<aidl::android::hardware::graphics::common::BufferUsage>(
+            hal_configured_streams[i].producer_usage);
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.v3_2.consumerUsage =
-        hal_configured_streams[i].consumer_usage;
+    dst.consumerUsage =
+        static_cast<aidl::android::hardware::graphics::common::BufferUsage>(
+            hal_configured_streams[i].consumer_usage);
 
-    hidl_hal_stream_config->streams[i].v3_4.v3_3.v3_2.maxBuffers =
-        hal_configured_streams[i].max_buffers;
+    dst.maxBuffers = hal_configured_streams[i].max_buffers;
   }
 
   return OK;
@@ -223,7 +226,7 @@ status_t ConvertToHidlHalStreamConfig(
 
 status_t WriteToResultMetadataQueue(
     camera_metadata_t* metadata,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue) {
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue) {
   if (result_metadata_queue == nullptr) {
     return BAD_VALUE;
   }
@@ -235,7 +238,7 @@ status_t WriteToResultMetadataQueue(
 
   uint32_t size = get_camera_metadata_size(metadata);
   bool success = result_metadata_queue->write(
-      reinterpret_cast<const uint8_t*>(metadata), size);
+      reinterpret_cast<const int8_t*>(metadata), size);
   if (!success) {
     ALOGW("%s: Writing to result metadata queue failed. (size=%u)",
           __FUNCTION__, size);
@@ -249,7 +252,7 @@ status_t WriteToResultMetadataQueue(
 // the metadata to the caller in out_hal_metadata.
 status_t TryWritingToResultMetadataQueue(
     std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue,
     uint64_t* fmq_result_size,
     std::unique_ptr<google_camera_hal::HalCameraMetadata>* out_hal_metadata) {
   if (out_hal_metadata == nullptr) {
@@ -285,43 +288,44 @@ status_t TryWritingToResultMetadataQueue(
   return OK;
 }
 
-status_t ConverToHidlResultMetadata(
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
+status_t ConvertToAidlResultMetadata(
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue,
     std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,
-    CameraMetadata* hidl_metadata, uint64_t* fmq_result_size) {
+    std::vector<uint8_t>* aidl_metadata, uint64_t* fmq_result_size) {
   if (TryWritingToResultMetadataQueue(std::move(hal_metadata),
                                       result_metadata_queue, fmq_result_size,
                                       &hal_metadata) == OK) {
     return OK;
   }
 
-  // If writing to metadata queue failed, attach the metadata to hidl_metadata.
-  if (hidl_metadata == nullptr) {
-    ALOGE("%s: hidl_metadata is nullptr", __FUNCTION__);
+  // If writing to metadata queue failed, attach the metadata to aidl_metadata.
+  if (aidl_metadata == nullptr) {
+    ALOGE("%s: aidl_metadata is nullptr", __FUNCTION__);
     return BAD_VALUE;
   }
 
   uint32_t metadata_size = hal_metadata->GetCameraMetadataSize();
-  hidl_metadata->setToExternal(
-      reinterpret_cast<uint8_t*>(hal_metadata->ReleaseCameraMetadata()),
-      metadata_size, /*shouldOwn=*/true);
+  uint8_t* metadata_p =
+      reinterpret_cast<uint8_t*>(hal_metadata->ReleaseCameraMetadata());
+  // TODO: Do we reallly need to copy here ?
+  aidl_metadata->assign(metadata_p, metadata_p + metadata_size);
 
   return OK;
 }
 
-status_t ConvertToHidlBufferStatus(google_camera_hal::BufferStatus hal_status,
-                                   BufferStatus* hidl_status) {
-  if (hidl_status == nullptr) {
-    ALOGE("%s: hidl_status is nullptr.", __FUNCTION__);
+status_t ConvertToAidlBufferStatus(google_camera_hal::BufferStatus hal_status,
+                                   BufferStatus* aidl_status) {
+  if (aidl_status == nullptr) {
+    ALOGE("%s: aidl_status is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
   switch (hal_status) {
     case google_camera_hal::BufferStatus::kOk:
-      *hidl_status = BufferStatus::OK;
+      *aidl_status = BufferStatus::OK;
       break;
     case google_camera_hal::BufferStatus::kError:
-      *hidl_status = BufferStatus::ERROR;
+      *aidl_status = BufferStatus::ERROR;
       break;
     default:
       ALOGE("%s: Unknown HAL buffer status: %u", __FUNCTION__, hal_status);
@@ -331,37 +335,44 @@ status_t ConvertToHidlBufferStatus(google_camera_hal::BufferStatus hal_status,
   return OK;
 }
 
-status_t ConvertToHidlStreamBuffer(
+aidl::android::hardware::common::NativeHandle makeToAidlIfNotNull(
+    const native_handle_t* nh) {
+  if (nh == nullptr) {
+    return aidl::android::hardware::common::NativeHandle();
+  }
+  return makeToAidl(nh);
+}
+
+status_t ConvertToAidlStreamBuffer(
     const google_camera_hal::StreamBuffer& hal_buffer,
-    StreamBuffer* hidl_buffer) {
-  if (hidl_buffer == nullptr) {
-    ALOGE("%s: hidl_buffer is nullptr", __FUNCTION__);
+    StreamBuffer* aidl_buffer) {
+  if (aidl_buffer == nullptr) {
+    ALOGE("%s: aidl_buffer is nullptr", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hidl_buffer->streamId = hal_buffer.stream_id;
-  hidl_buffer->bufferId = hal_buffer.buffer_id;
-  hidl_buffer->buffer = nullptr;
+  aidl_buffer->streamId = hal_buffer.stream_id;
+  aidl_buffer->bufferId = hal_buffer.buffer_id;
+  aidl_buffer->buffer = aidl::android::hardware::common::NativeHandle();
 
   status_t res =
-      ConvertToHidlBufferStatus(hal_buffer.status, &hidl_buffer->status);
+      ConvertToAidlBufferStatus(hal_buffer.status, &aidl_buffer->status);
   if (res != OK) {
-    ALOGE("%s: Converting to HIDL buffer status failed: %s(%d)", __FUNCTION__,
+    ALOGE("%s: Converting to AIDL buffer status failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return res;
   }
 
-  hidl_buffer->acquireFence = nullptr;
-  hidl_buffer->releaseFence = hal_buffer.release_fence;
+  aidl_buffer->acquireFence = aidl::android::hardware::common::NativeHandle();
+  aidl_buffer->releaseFence = makeToAidlIfNotNull(hal_buffer.release_fence);
   return OK;
 }
 
-status_t ConvertToHidlCaptureResult_V3_2(
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
-    google_camera_hal::CaptureResult* hal_result,
-    device::V3_2::CaptureResult* hidl_result) {
-  if (hidl_result == nullptr) {
-    ALOGE("%s: hidl_result is nullptr.", __FUNCTION__);
+status_t ConvertToAidlCaptureResultInternal(
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue,
+    google_camera_hal::CaptureResult* hal_result, CaptureResult* aidl_result) {
+  if (aidl_result == nullptr) {
+    ALOGE("%s: aidl_result is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
@@ -370,23 +381,23 @@ status_t ConvertToHidlCaptureResult_V3_2(
     return BAD_VALUE;
   }
 
-  hidl_result->frameNumber = hal_result->frame_number;
+  aidl_result->frameNumber = hal_result->frame_number;
 
-  status_t res = ConverToHidlResultMetadata(
+  status_t res = ConvertToAidlResultMetadata(
       result_metadata_queue, std::move(hal_result->result_metadata),
-      &hidl_result->result, &hidl_result->fmqResultSize);
+      &aidl_result->result.metadata, (uint64_t*)&aidl_result->fmqResultSize);
   if (res != OK) {
-    ALOGE("%s: Converting to HIDL result metadata failed: %s(%d).",
+    ALOGE("%s: Converting to AIDL result metadata failed: %s(%d).",
           __FUNCTION__, strerror(-res), res);
     return res;
   }
 
-  hidl_result->outputBuffers.resize(hal_result->output_buffers.size());
-  for (uint32_t i = 0; i < hidl_result->outputBuffers.size(); i++) {
-    res = ConvertToHidlStreamBuffer(hal_result->output_buffers[i],
-                                    &hidl_result->outputBuffers[i]);
+  aidl_result->outputBuffers.resize(hal_result->output_buffers.size());
+  for (uint32_t i = 0; i < aidl_result->outputBuffers.size(); i++) {
+    res = ConvertToAidlStreamBuffer(hal_result->output_buffers[i],
+                                    &aidl_result->outputBuffers[i]);
     if (res != OK) {
-      ALOGE("%s: Converting to HIDL output stream buffer failed: %s(%d)",
+      ALOGE("%s: Converting to AIDL output stream buffer failed: %s(%d)",
             __FUNCTION__, strerror(-res), res);
       return res;
     }
@@ -399,27 +410,27 @@ status_t ConvertToHidlCaptureResult_V3_2(
             __FUNCTION__, num_input_buffers);
     }
 
-    res = ConvertToHidlStreamBuffer(hal_result->input_buffers[0],
-                                    &hidl_result->inputBuffer);
+    res = ConvertToAidlStreamBuffer(hal_result->input_buffers[0],
+                                    &aidl_result->inputBuffer);
     if (res != OK) {
-      ALOGE("%s: Converting to HIDL input stream buffer failed: %s(%d)",
+      ALOGE("%s: Converting to AIDL input stream buffer failed: %s(%d)",
             __FUNCTION__, strerror(-res), res);
       return res;
     }
   } else {
-    hidl_result->inputBuffer.streamId = -1;
+    aidl_result->inputBuffer.streamId = -1;
   }
 
-  hidl_result->partialResult = hal_result->partial_result;
+  aidl_result->partialResult = hal_result->partial_result;
   return OK;
 }
 
-status_t ConvertToHidlCaptureResult(
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
+status_t ConvertToAidlCaptureResult(
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue,
     std::unique_ptr<google_camera_hal::CaptureResult> hal_result,
-    CaptureResult* hidl_result) {
-  if (hidl_result == nullptr) {
-    ALOGE("%s: hidl_result is nullptr.", __FUNCTION__);
+    CaptureResult* aidl_result) {
+  if (aidl_result == nullptr) {
+    ALOGE("%s: aidl_result is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
@@ -428,28 +439,28 @@ status_t ConvertToHidlCaptureResult(
     return BAD_VALUE;
   }
 
-  status_t res = ConvertToHidlCaptureResult_V3_2(
-      result_metadata_queue, hal_result.get(), &hidl_result->v3_2);
+  status_t res = ConvertToAidlCaptureResultInternal(
+      result_metadata_queue, hal_result.get(), aidl_result);
   if (res != OK) {
-    ALOGE("%s: Converting to V3.2 HIDL result failed: %s(%d).", __FUNCTION__,
-          strerror(-res), res);
+    ALOGE("%s: Converting to AIDL result internal failed: %s(%d).",
+          __FUNCTION__, strerror(-res), res);
     return res;
   }
 
   uint32_t num_physical_metadata = hal_result->physical_metadata.size();
-  hidl_result->physicalCameraMetadata.resize(num_physical_metadata);
+  aidl_result->physicalCameraMetadata.resize(num_physical_metadata);
 
   for (uint32_t i = 0; i < num_physical_metadata; i++) {
-    hidl_result->physicalCameraMetadata[i].physicalCameraId =
+    aidl_result->physicalCameraMetadata[i].physicalCameraId =
         std::to_string(hal_result->physical_metadata[i].physical_camera_id);
 
-    res = ConverToHidlResultMetadata(
+    res = ConvertToAidlResultMetadata(
         result_metadata_queue,
         std::move(hal_result->physical_metadata[i].metadata),
-        &hidl_result->physicalCameraMetadata[i].metadata,
-        &hidl_result->physicalCameraMetadata[i].fmqMetadataSize);
+        &aidl_result->physicalCameraMetadata[i].metadata.metadata,
+        (uint64_t*)&aidl_result->physicalCameraMetadata[i].fmqMetadataSize);
     if (res != OK) {
-      ALOGE("%s: Converting to HIDL physical metadata failed: %s(%d).",
+      ALOGE("%s: Converting to AIDL physical metadata failed: %s(%d).",
             __FUNCTION__, strerror(-res), res);
       return res;
     }
@@ -458,76 +469,77 @@ status_t ConvertToHidlCaptureResult(
   return OK;
 }
 
-status_t ConvertToHidlErrorMessage(
-    const google_camera_hal::ErrorMessage& hal_error, ErrorMsg* hidl_error) {
-  if (hidl_error == nullptr) {
-    ALOGE("%s: hidl_error is nullptr.", __FUNCTION__);
+status_t ConvertToAidlErrorMessage(
+    const google_camera_hal::ErrorMessage& hal_error, NotifyMsg* aidl_msg) {
+  using Tag = aidl::android::hardware::camera::device::NotifyMsg::Tag;
+  if (aidl_msg == nullptr) {
+    ALOGE("%s: aidl_msg is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hidl_error->frameNumber = hal_error.frame_number;
-  hidl_error->errorStreamId = hal_error.error_stream_id;
+  ErrorMsg aidl_error;
+  aidl_error.frameNumber = hal_error.frame_number;
+  aidl_error.errorStreamId = hal_error.error_stream_id;
 
   switch (hal_error.error_code) {
     case google_camera_hal::ErrorCode::kErrorDevice:
-      hidl_error->errorCode = ErrorCode::ERROR_DEVICE;
+      aidl_error.errorCode = ErrorCode::ERROR_DEVICE;
       break;
     case google_camera_hal::ErrorCode::kErrorRequest:
-      hidl_error->errorCode = ErrorCode::ERROR_REQUEST;
+      aidl_error.errorCode = ErrorCode::ERROR_REQUEST;
       break;
     case google_camera_hal::ErrorCode::kErrorResult:
-      hidl_error->errorCode = ErrorCode::ERROR_RESULT;
+      aidl_error.errorCode = ErrorCode::ERROR_RESULT;
       break;
     case google_camera_hal::ErrorCode::kErrorBuffer:
-      hidl_error->errorCode = ErrorCode::ERROR_BUFFER;
+      aidl_error.errorCode = ErrorCode::ERROR_BUFFER;
       break;
     default:
       ALOGE("%s: Unknown error code: %u", __FUNCTION__, hal_error.error_code);
       return BAD_VALUE;
   }
-
+  aidl_msg->set<Tag::error>(aidl_error);
   return OK;
 }
 
-status_t ConvertToHidlShutterMessage(
-    const google_camera_hal::ShutterMessage& hal_shutter,
-    ShutterMsg* hidl_shutter) {
-  if (hidl_shutter == nullptr) {
-    ALOGE("%s: hidl_shutter is nullptr.", __FUNCTION__);
+status_t ConvertToAidlShutterMessage(
+    const google_camera_hal::ShutterMessage& hal_shutter, NotifyMsg* aidl_msg) {
+  using Tag = aidl::android::hardware::camera::device::NotifyMsg::Tag;
+  if (aidl_msg == nullptr) {
+    ALOGE("%s: aidl_msg is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
-
-  hidl_shutter->frameNumber = hal_shutter.frame_number;
-  hidl_shutter->timestamp = hal_shutter.timestamp_ns;
+  ShutterMsg aidl_shutter;
+  aidl_shutter.frameNumber = hal_shutter.frame_number;
+  aidl_shutter.timestamp = hal_shutter.timestamp_ns;
+  aidl_shutter.readoutTimestamp = hal_shutter.readout_timestamp_ns;
+  aidl_msg->set<Tag::shutter>(aidl_shutter);
   return OK;
 }
 
-status_t ConverToHidlNotifyMessage(
+status_t ConverToAidlNotifyMessage(
     const google_camera_hal::NotifyMessage& hal_message,
-    NotifyMsg* hidl_message) {
-  if (hidl_message == nullptr) {
-    ALOGE("%s: hidl_message is nullptr.", __FUNCTION__);
+    NotifyMsg* aidl_message) {
+  if (aidl_message == nullptr) {
+    ALOGE("%s: aidl_message is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
   status_t res;
   switch (hal_message.type) {
     case google_camera_hal::MessageType::kError:
-      hidl_message->type = MsgType::ERROR;
-      res = ConvertToHidlErrorMessage(hal_message.message.error,
-                                      &hidl_message->msg.error);
+      res = ConvertToAidlErrorMessage(hal_message.message.error, aidl_message);
       if (res != OK) {
-        ALOGE("%s: Converting to HIDL error message failed: %s(%d)",
+        ALOGE("%s: Converting to AIDL error message failed: %s(%d)",
               __FUNCTION__, strerror(-res), res);
         return res;
       }
       break;
     case google_camera_hal::MessageType::kShutter:
-      hidl_message->type = MsgType::SHUTTER;
-      res = ConvertToHidlShutterMessage(hal_message.message.shutter,
-                                        &hidl_message->msg.shutter);
+      res = ConvertToAidlShutterMessage(hal_message.message.shutter,
+                                        aidl_message);
       if (res != OK) {
-        ALOGE("%s: Converting to HIDL shutter message failed: %s(%d)",
+        ALOGE("%s: Converting to AIDL shutter message failed: %s(%d)",
               __FUNCTION__, strerror(-res), res);
         return res;
       }
@@ -540,23 +552,23 @@ status_t ConverToHidlNotifyMessage(
   return OK;
 }
 
-status_t ConvertToHidlCameraDeviceStatus(
+status_t ConvertToAidlCameraDeviceStatus(
     google_camera_hal::CameraDeviceStatus hal_camera_device_status,
-    CameraDeviceStatus* hidl_camera_device_status) {
-  if (hidl_camera_device_status == nullptr) {
-    ALOGE("%s: hidl_camera_device_status is nullptr.", __FUNCTION__);
+    CameraDeviceStatus* aidl_camera_device_status) {
+  if (aidl_camera_device_status == nullptr) {
+    ALOGE("%s: aidl_camera_device_status is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
   switch (hal_camera_device_status) {
     case google_camera_hal::CameraDeviceStatus::kNotPresent:
-      *hidl_camera_device_status = CameraDeviceStatus::NOT_PRESENT;
+      *aidl_camera_device_status = CameraDeviceStatus::NOT_PRESENT;
       break;
     case google_camera_hal::CameraDeviceStatus::kPresent:
-      *hidl_camera_device_status = CameraDeviceStatus::PRESENT;
+      *aidl_camera_device_status = CameraDeviceStatus::PRESENT;
       break;
     case google_camera_hal::CameraDeviceStatus::kEnumerating:
-      *hidl_camera_device_status = CameraDeviceStatus::ENUMERATING;
+      *aidl_camera_device_status = CameraDeviceStatus::ENUMERATING;
       break;
     default:
       ALOGE("%s: Unknown HAL camera device status: %u", __FUNCTION__,
@@ -567,23 +579,23 @@ status_t ConvertToHidlCameraDeviceStatus(
   return OK;
 }
 
-status_t ConvertToHidlTorchModeStatus(
+status_t ConvertToAidlTorchModeStatus(
     google_camera_hal::TorchModeStatus hal_torch_status,
-    TorchModeStatus* hidl_torch_status) {
-  if (hidl_torch_status == nullptr) {
-    ALOGE("%s: hidl_torch_status is nullptr.", __FUNCTION__);
+    TorchModeStatus* aidl_torch_status) {
+  if (aidl_torch_status == nullptr) {
+    ALOGE("%s: aidl_torch_status is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
   switch (hal_torch_status) {
     case google_camera_hal::TorchModeStatus::kNotAvailable:
-      *hidl_torch_status = TorchModeStatus::NOT_AVAILABLE;
+      *aidl_torch_status = TorchModeStatus::NOT_AVAILABLE;
       break;
     case google_camera_hal::TorchModeStatus::kAvailableOff:
-      *hidl_torch_status = TorchModeStatus::AVAILABLE_OFF;
+      *aidl_torch_status = TorchModeStatus::AVAILABLE_OFF;
       break;
     case google_camera_hal::TorchModeStatus::kAvailableOn:
-      *hidl_torch_status = TorchModeStatus::AVAILABLE_ON;
+      *aidl_torch_status = TorchModeStatus::AVAILABLE_ON;
       break;
     default:
       ALOGE("%s: Unknown HAL torch mode status: %u", __FUNCTION__,
@@ -594,31 +606,31 @@ status_t ConvertToHidlTorchModeStatus(
   return OK;
 }
 
-status_t ConvertToHidlBufferRequest(
+status_t ConvertToAidlBufferRequest(
     const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
-    hidl_vec<BufferRequest>* hidl_buffer_requests) {
-  if (hidl_buffer_requests == nullptr) {
-    ALOGE("%s: hidl_buffer_request is nullptr.", __FUNCTION__);
+    std::vector<BufferRequest>* aidl_buffer_requests) {
+  if (aidl_buffer_requests == nullptr) {
+    ALOGE("%s: aidl_buffer_request is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hidl_buffer_requests->resize(hal_buffer_requests.size());
+  aidl_buffer_requests->resize(hal_buffer_requests.size());
   for (uint32_t i = 0; i < hal_buffer_requests.size(); i++) {
-    (*hidl_buffer_requests)[i].streamId = hal_buffer_requests[i].stream_id;
-    (*hidl_buffer_requests)[i].numBuffersRequested =
+    (*aidl_buffer_requests)[i].streamId = hal_buffer_requests[i].stream_id;
+    (*aidl_buffer_requests)[i].numBuffersRequested =
         hal_buffer_requests[i].num_buffers_requested;
   }
   return OK;
 }
 
-status_t ConvertToHalBufferStatus(BufferStatus hidl_status,
+status_t ConvertToHalBufferStatus(BufferStatus aidl_status,
                                   google_camera_hal::BufferStatus* hal_status) {
   if (hal_status == nullptr) {
     ALOGE("%s: hal_status is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_status) {
+  switch (aidl_status) {
     case BufferStatus::OK:
       *hal_status = google_camera_hal::BufferStatus::kOk;
       break;
@@ -626,42 +638,71 @@ status_t ConvertToHalBufferStatus(BufferStatus hidl_status,
       *hal_status = google_camera_hal::BufferStatus::kError;
       break;
     default:
-      ALOGE("%s: Unknown HIDL buffer status: %u", __FUNCTION__, hidl_status);
+      ALOGE("%s: Unknown AIDL buffer status: %u", __FUNCTION__, aidl_status);
       return BAD_VALUE;
   }
 
   return OK;
 }
 
-status_t ConvertToHalStreamBuffer(const StreamBuffer& hidl_buffer,
-                                  google_camera_hal::StreamBuffer* hal_buffer) {
-  if (hal_buffer == nullptr) {
-    ALOGE("%s: hal_buffer is nullptr.", __FUNCTION__);
+bool IsAidlNativeHandleNull(const NativeHandle& handle) {
+  return (handle.fds.size() == 0 && handle.ints.size() == 0);
+}
+
+native_handle_t* makeFromAidlIfNotNull(const NativeHandle& handle) {
+  if (IsAidlNativeHandleNull(handle)) {
+    return nullptr;
+  }
+  return makeFromAidl(handle);
+}
+
+// We have a handles_to_delete parameter since makeFromAidl creates a
+// native_handle_t
+status_t ConvertToHalStreamBuffer(
+    const StreamBuffer& aidl_buffer, google_camera_hal::StreamBuffer* hal_buffer,
+    std::vector<native_handle_t*>* handles_to_delete) {
+  if (hal_buffer == nullptr || handles_to_delete == nullptr) {
+    ALOGE("%s: hal_buffer / handles_to_delete is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hal_buffer->stream_id = hidl_buffer.streamId;
-  hal_buffer->buffer_id = hidl_buffer.bufferId;
-  hal_buffer->buffer = hidl_buffer.buffer.getNativeHandle();
+  hal_buffer->stream_id = aidl_buffer.streamId;
+  hal_buffer->buffer_id = aidl_buffer.bufferId;
+  native_handle_t* buf_handle = makeFromAidlIfNotNull(aidl_buffer.buffer);
+  hal_buffer->buffer = buf_handle;
+  if (buf_handle != nullptr) {
+    handles_to_delete->emplace_back(buf_handle);
+  }
 
   status_t res =
-      ConvertToHalBufferStatus(hidl_buffer.status, &hal_buffer->status);
+      ConvertToHalBufferStatus(aidl_buffer.status, &hal_buffer->status);
   if (res != OK) {
     ALOGE("%s: Converting to HAL buffer status failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return res;
   }
 
-  hal_buffer->acquire_fence = hidl_buffer.acquireFence.getNativeHandle();
-  hal_buffer->release_fence = hidl_buffer.releaseFence.getNativeHandle();
+  native_handle_t* acquire_handle =
+      makeFromAidlIfNotNull(aidl_buffer.acquireFence);
+  native_handle_t* release_handle =
+      makeFromAidlIfNotNull(aidl_buffer.releaseFence);
+  hal_buffer->acquire_fence = acquire_handle;
+  hal_buffer->release_fence = release_handle;
+  if (acquire_handle != nullptr) {
+    handles_to_delete->emplace_back(acquire_handle);
+  }
+
+  if (release_handle != nullptr) {
+    handles_to_delete->emplace_back(release_handle);
+  }
 
   return OK;
 }
 
 status_t ConvertToHalMetadata(
     uint32_t message_queue_setting_size,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
-    const CameraMetadata& request_settings,
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* request_metadata_queue,
+    const std::vector<uint8_t>& request_settings,
     std::unique_ptr<google_camera_hal::HalCameraMetadata>* hal_metadata) {
   if (hal_metadata == nullptr) {
     ALOGE("%s: hal_metadata is nullptr.", __FUNCTION__);
@@ -669,7 +710,7 @@ status_t ConvertToHalMetadata(
   }
 
   const camera_metadata_t* metadata = nullptr;
-  CameraMetadata metadata_queue_settings;
+  std::vector<int8_t> metadata_queue_settings;
 
   if (message_queue_setting_size == 0) {
     // Use the settings in the request.
@@ -706,19 +747,20 @@ status_t ConvertToHalMetadata(
 }
 
 status_t ConvertToHalCaptureRequest(
-    const CaptureRequest& hidl_request,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
-    google_camera_hal::CaptureRequest* hal_request) {
+    const CaptureRequest& aidl_request,
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* request_metadata_queue,
+    google_camera_hal::CaptureRequest* hal_request,
+    std::vector<native_handle_t*>* handles_to_delete) {
   if (hal_request == nullptr) {
     ALOGE("%s: hal_request is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  hal_request->frame_number = hidl_request.v3_4.v3_2.frameNumber;
+  hal_request->frame_number = aidl_request.frameNumber;
 
   status_t res = ConvertToHalMetadata(
-      hidl_request.v3_4.v3_2.fmqSettingsSize, request_metadata_queue,
-      hidl_request.v3_4.v3_2.settings, &hal_request->settings);
+      aidl_request.fmqSettingsSize, request_metadata_queue,
+      aidl_request.settings.metadata, &hal_request->settings);
   if (res != OK) {
     ALOGE("%s: Converting metadata failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
@@ -726,9 +768,9 @@ status_t ConvertToHalCaptureRequest(
   }
 
   google_camera_hal::StreamBuffer hal_buffer = {};
-  if (hidl_request.v3_4.v3_2.inputBuffer.buffer != nullptr) {
-    res = ConvertToHalStreamBuffer(hidl_request.v3_4.v3_2.inputBuffer,
-                                   &hal_buffer);
+  if (!IsAidlNativeHandleNull(aidl_request.inputBuffer.buffer)) {
+    res = ConvertToHalStreamBuffer(aidl_request.inputBuffer, &hal_buffer,
+                                   handles_to_delete);
     if (res != OK) {
       ALOGE("%s: Converting hal stream buffer failed: %s(%d)", __FUNCTION__,
             strerror(-res), res);
@@ -736,13 +778,14 @@ status_t ConvertToHalCaptureRequest(
     }
 
     hal_request->input_buffers.push_back(hal_buffer);
-    hal_request->input_width = hidl_request.inputWidth;
-    hal_request->input_height = hidl_request.inputHeight;
+    hal_request->input_width = aidl_request.inputWidth;
+    hal_request->input_height = aidl_request.inputHeight;
   }
 
-  for (auto& buffer : hidl_request.v3_4.v3_2.outputBuffers) {
+  for (auto& buffer : aidl_request.outputBuffers) {
     hal_buffer = {};
-    status_t res = ConvertToHalStreamBuffer(buffer, &hal_buffer);
+    status_t res =
+        ConvertToHalStreamBuffer(buffer, &hal_buffer, handles_to_delete);
     if (res != OK) {
       ALOGE("%s: Converting hal stream buffer failed: %s(%d)", __FUNCTION__,
             strerror(-res), res);
@@ -752,18 +795,18 @@ status_t ConvertToHalCaptureRequest(
     hal_request->output_buffers.push_back(hal_buffer);
   }
 
-  for (auto hidl_physical_settings : hidl_request.v3_4.physicalCameraSettings) {
+  for (auto aidl_physical_settings : aidl_request.physicalCameraSettings) {
     std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_physical_settings;
     res = ConvertToHalMetadata(
-        hidl_physical_settings.fmqSettingsSize, request_metadata_queue,
-        hidl_physical_settings.settings, &hal_physical_settings);
+        aidl_physical_settings.fmqSettingsSize, request_metadata_queue,
+        aidl_physical_settings.settings.metadata, &hal_physical_settings);
     if (res != OK) {
       ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
             strerror(-res), res);
       return res;
     }
 
-    uint32_t camera_id = std::stoul(hidl_physical_settings.physicalCameraId);
+    uint32_t camera_id = std::stoul(aidl_physical_settings.physicalCameraId);
     hal_request->physical_camera_settings.emplace(
         camera_id, std::move(hal_physical_settings));
   }
@@ -772,17 +815,17 @@ status_t ConvertToHalCaptureRequest(
 }
 
 status_t ConvertToHalBufferCaches(
-    const hidl_vec<BufferCache>& hidl_buffer_caches,
+    const std::vector<BufferCache>& aidl_buffer_caches,
     std::vector<google_camera_hal::BufferCache>* hal_buffer_caches) {
   if (hal_buffer_caches == nullptr) {
     ALOGE("%s: hal_buffer_caches is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  for (auto hidl_cache : hidl_buffer_caches) {
+  for (auto aidl_cache : aidl_buffer_caches) {
     google_camera_hal::BufferCache hal_cache;
-    hal_cache.stream_id = hidl_cache.streamId;
-    hal_cache.buffer_id = hidl_cache.bufferId;
+    hal_cache.stream_id = aidl_cache.streamId;
+    hal_cache.buffer_id = aidl_cache.bufferId;
 
     hal_buffer_caches->push_back(hal_cache);
   }
@@ -791,14 +834,14 @@ status_t ConvertToHalBufferCaches(
 }
 
 status_t ConvertToHalStreamConfigurationMode(
-    StreamConfigurationMode hidl_mode,
+    StreamConfigurationMode aidl_mode,
     google_camera_hal::StreamConfigurationMode* hal_mode) {
   if (hal_mode == nullptr) {
     ALOGE("%s: hal_mode is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_mode) {
+  switch (aidl_mode) {
     case StreamConfigurationMode::NORMAL_MODE:
       *hal_mode = google_camera_hal::StreamConfigurationMode::kNormal;
       break;
@@ -807,25 +850,25 @@ status_t ConvertToHalStreamConfigurationMode(
           google_camera_hal::StreamConfigurationMode::kConstrainedHighSpeed;
       break;
     default:
-      ALOGE("%s: Unknown configuration mode %u", __FUNCTION__, hidl_mode);
+      ALOGE("%s: Unknown configuration mode %u", __FUNCTION__, aidl_mode);
       return BAD_VALUE;
   }
 
   return OK;
 }
 
-static bool sensorPixelModeContains(const device::V3_7::Stream& hidl_stream,
-                                    uint32_t key) {
-  for (auto& i : hidl_stream.sensorPixelModesUsed) {
-    if (i == static_cast<CameraMetadataEnumAndroidSensorPixelMode>(key)) {
+static bool sensorPixelModeContains(const Stream& aidl_stream, uint32_t key) {
+  using aidl::android::hardware::camera::metadata::SensorPixelMode;
+  for (auto& i : aidl_stream.sensorPixelModesUsed) {
+    if (i == static_cast<SensorPixelMode>(key)) {
       return true;
     }
   }
   return false;
 }
 
-status_t ConverToHalStreamConfig(
-    const StreamConfiguration& hidl_stream_config,
+status_t ConvertToHalStreamConfig(
+    const StreamConfiguration& aidl_stream_config,
     google_camera_hal::StreamConfiguration* hal_stream_config) {
   if (hal_stream_config == nullptr) {
     ALOGE("%s: hal_stream_config is nullptr.", __FUNCTION__);
@@ -834,27 +877,18 @@ status_t ConverToHalStreamConfig(
 
   status_t res;
 
-  for (auto hidl_stream : hidl_stream_config.streams) {
+  for (auto aidl_stream : aidl_stream_config.streams) {
     google_camera_hal::Stream hal_stream;
-    res = ConvertToHalStream(hidl_stream.v3_4, &hal_stream);
+    res = ConvertToHalStream(aidl_stream, &hal_stream);
     if (res != OK) {
       ALOGE("%s: Converting to HAL stream failed: %s(%d)", __FUNCTION__,
             strerror(-res), res);
       return res;
     }
-    hal_stream.group_id = hidl_stream.groupId;
-
-    hal_stream.used_in_max_resolution_mode = sensorPixelModeContains(
-        hidl_stream, ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION);
-    hal_stream.used_in_default_resolution_mode =
-        hidl_stream.sensorPixelModesUsed.size() > 0
-            ? sensorPixelModeContains(hidl_stream,
-                                      ANDROID_SENSOR_PIXEL_MODE_DEFAULT)
-            : true;
     hal_stream_config->streams.push_back(hal_stream);
   }
 
-  res = ConvertToHalStreamConfigurationMode(hidl_stream_config.operationMode,
+  res = ConvertToHalStreamConfigurationMode(aidl_stream_config.operationMode,
                                             &hal_stream_config->operation_mode);
   if (res != OK) {
     ALOGE("%s: Converting to HAL opeation mode failed: %s(%d)", __FUNCTION__,
@@ -862,7 +896,8 @@ status_t ConverToHalStreamConfig(
     return res;
   }
 
-  res = ConvertToHalMetadata(0, nullptr, hidl_stream_config.sessionParams,
+  res = ConvertToHalMetadata(0, nullptr,
+                             aidl_stream_config.sessionParams.metadata,
                              &hal_stream_config->session_params);
   if (res != OK) {
     ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
@@ -871,60 +906,21 @@ status_t ConverToHalStreamConfig(
   }
 
   hal_stream_config->stream_config_counter =
-      hidl_stream_config.streamConfigCounter;
+      aidl_stream_config.streamConfigCounter;
   hal_stream_config->multi_resolution_input_image =
-      hidl_stream_config.multiResolutionInputImage;
-
-  return OK;
-}
-
-status_t ConverToHalStreamConfig(
-    const device::V3_4::StreamConfiguration& hidl_stream_config,
-    google_camera_hal::StreamConfiguration* hal_stream_config) {
-  if (hal_stream_config == nullptr) {
-    ALOGE("%s: hal_stream_config is nullptr.", __FUNCTION__);
-    return BAD_VALUE;
-  }
-
-  status_t res;
-  for (auto hidl_stream : hidl_stream_config.streams) {
-    google_camera_hal::Stream hal_stream;
-    res = ConvertToHalStream(hidl_stream, &hal_stream);
-    if (res != OK) {
-      ALOGE("%s: Converting to HAL stream failed: %s(%d)", __FUNCTION__,
-            strerror(-res), res);
-      return res;
-    }
-    hal_stream_config->streams.push_back(hal_stream);
-  }
-
-  res = ConvertToHalStreamConfigurationMode(hidl_stream_config.operationMode,
-                                            &hal_stream_config->operation_mode);
-  if (res != OK) {
-    ALOGE("%s: Converting to HAL opeation mode failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    return res;
-  }
-
-  res = ConvertToHalMetadata(0, nullptr, hidl_stream_config.sessionParams,
-                             &hal_stream_config->session_params);
-  if (res != OK) {
-    ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    return res;
-  }
+      aidl_stream_config.multiResolutionInputImage;
 
   return OK;
 }
 
-status_t ConvertToHalStreamType(StreamType hidl_stream_type,
+status_t ConvertToHalStreamType(StreamType aidl_stream_type,
                                 google_camera_hal::StreamType* hal_stream_type) {
   if (hal_stream_type == nullptr) {
     ALOGE("%s: hal_stream_type is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_stream_type) {
+  switch (aidl_stream_type) {
     case StreamType::OUTPUT:
       *hal_stream_type = google_camera_hal::StreamType::kOutput;
       break;
@@ -932,7 +928,7 @@ status_t ConvertToHalStreamType(StreamType hidl_stream_type,
       *hal_stream_type = google_camera_hal::StreamType::kInput;
       break;
     default:
-      ALOGE("%s: Unknown stream type: %u", __FUNCTION__, hidl_stream_type);
+      ALOGE("%s: Unknown stream type: %u", __FUNCTION__, aidl_stream_type);
       return BAD_VALUE;
   }
 
@@ -940,14 +936,14 @@ status_t ConvertToHalStreamType(StreamType hidl_stream_type,
 }
 
 status_t ConvertToHalStreamRotation(
-    StreamRotation hidl_stream_rotation,
+    StreamRotation aidl_stream_rotation,
     google_camera_hal::StreamRotation* hal_stream_rotation) {
   if (hal_stream_rotation == nullptr) {
     ALOGE("%s: hal_stream_rotation is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_stream_rotation) {
+  switch (aidl_stream_rotation) {
     case StreamRotation::ROTATION_0:
       *hal_stream_rotation = google_camera_hal::StreamRotation::kRotation0;
       break;
@@ -962,14 +958,14 @@ status_t ConvertToHalStreamRotation(
       break;
     default:
       ALOGE("%s: Unknown stream rotation: %u", __FUNCTION__,
-            hidl_stream_rotation);
+            aidl_stream_rotation);
       return BAD_VALUE;
   }
 
   return OK;
 }
 
-status_t ConvertToHalStream(const Stream& hidl_stream,
+status_t ConvertToHalStream(const Stream& aidl_stream,
                             google_camera_hal::Stream* hal_stream) {
   if (hal_stream == nullptr) {
     ALOGE("%s: hal_stream is nullptr.", __FUNCTION__);
@@ -978,73 +974,66 @@ status_t ConvertToHalStream(const Stream& hidl_stream,
 
   *hal_stream = {};
 
-  hal_stream->id = hidl_stream.v3_2.id;
+  hal_stream->id = aidl_stream.id;
 
-  status_t res = ConvertToHalStreamType(hidl_stream.v3_2.streamType,
-                                        &hal_stream->stream_type);
+  status_t res =
+      ConvertToHalStreamType(aidl_stream.streamType, &hal_stream->stream_type);
   if (res != OK) {
     ALOGE("%s: Converting to HAL stream type failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return res;
   }
 
-  hal_stream->width = hidl_stream.v3_2.width;
-  hal_stream->height = hidl_stream.v3_2.height;
-  hal_stream->format = (android_pixel_format_t)hidl_stream.v3_2.format;
-  hal_stream->usage = (uint64_t)hidl_stream.v3_2.usage;
-  hal_stream->data_space = (android_dataspace_t)hidl_stream.v3_2.dataSpace;
+  hal_stream->width = aidl_stream.width;
+  hal_stream->height = aidl_stream.height;
+  hal_stream->format = (android_pixel_format_t)aidl_stream.format;
+  hal_stream->usage = (uint64_t)aidl_stream.usage;
+  hal_stream->data_space = (android_dataspace_t)aidl_stream.dataSpace;
 
-  res = ConvertToHalStreamRotation(hidl_stream.v3_2.rotation,
-                                   &hal_stream->rotation);
+  res = ConvertToHalStreamRotation(aidl_stream.rotation, &hal_stream->rotation);
   if (res != OK) {
     ALOGE("%s: Converting to HAL stream rotation failed: %s(%d)", __FUNCTION__,
           strerror(-res), res);
     return res;
   }
 
-  if (hidl_stream.physicalCameraId.empty()) {
+  if (aidl_stream.physicalCameraId.empty()) {
     hal_stream->is_physical_camera_stream = false;
   } else {
     hal_stream->is_physical_camera_stream = true;
-    hal_stream->physical_camera_id = std::stoul(hidl_stream.physicalCameraId);
+    hal_stream->physical_camera_id = std::stoul(aidl_stream.physicalCameraId);
   }
 
-  hal_stream->buffer_size = hidl_stream.bufferSize;
+  hal_stream->buffer_size = aidl_stream.bufferSize;
+  hal_stream->group_id = aidl_stream.groupId;
 
-  return OK;
-}
+  hal_stream->used_in_max_resolution_mode = sensorPixelModeContains(
+      aidl_stream, ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION);
+  hal_stream->used_in_default_resolution_mode =
+      aidl_stream.sensorPixelModesUsed.size() > 0
+          ? sensorPixelModeContains(aidl_stream,
+                                    ANDROID_SENSOR_PIXEL_MODE_DEFAULT)
+          : true;
+  hal_stream->dynamic_profile = static_cast<
+      camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
+      aidl_stream.dynamicRangeProfile);
 
-status_t ConvertToHalTorchMode(TorchMode hidl_torch_mode,
-                               google_camera_hal::TorchMode* hal_torch_mode) {
-  if (hal_torch_mode == nullptr) {
-    ALOGE("%s: hal_torch_mode is nullptr.", __FUNCTION__);
-    return BAD_VALUE;
-  }
-
-  switch (hidl_torch_mode) {
-    case TorchMode::ON:
-      *hal_torch_mode = google_camera_hal::TorchMode::kOn;
-      break;
-    case TorchMode::OFF:
-      *hal_torch_mode = google_camera_hal::TorchMode::kOff;
-      break;
-    default:
-      ALOGE("%s: Unknown torch mode: %u", __FUNCTION__, hidl_torch_mode);
-      return BAD_VALUE;
-  }
+  hal_stream->use_case =
+      static_cast<camera_metadata_enum_android_scaler_available_stream_use_cases>(
+          aidl_stream.useCase);
 
   return OK;
 }
 
 status_t ConvertToHalBufferRequestStatus(
-    const BufferRequestStatus& hidl_buffer_request_status,
+    const BufferRequestStatus& aidl_buffer_request_status,
     google_camera_hal::BufferRequestStatus* hal_buffer_request_status) {
   if (hal_buffer_request_status == nullptr) {
     ALOGE("%s: hal_buffer_request_status is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  switch (hidl_buffer_request_status) {
+  switch (aidl_buffer_request_status) {
     case BufferRequestStatus::OK:
       *hal_buffer_request_status = google_camera_hal::BufferRequestStatus::kOk;
       break;
@@ -1066,7 +1055,7 @@ status_t ConvertToHalBufferRequestStatus(
       break;
     default:
       ALOGE("%s: Failed unknown buffer request error code %d", __FUNCTION__,
-            hidl_buffer_request_status);
+            aidl_buffer_request_status);
       return BAD_VALUE;
   }
 
@@ -1074,16 +1063,16 @@ status_t ConvertToHalBufferRequestStatus(
 }
 
 status_t ConvertToHalBufferReturnStatus(
-    const StreamBufferRet& hidl_stream_buffer_return,
+    const StreamBufferRet& aidl_stream_buffer_return,
     google_camera_hal::BufferReturn* hal_buffer_return) {
+  using Tag = aidl::android::hardware::camera::device::StreamBuffersVal::Tag;
   if (hal_buffer_return == nullptr) {
     ALOGE("%s: hal_buffer_return is nullptr.", __FUNCTION__);
     return BAD_VALUE;
   }
 
-  if (hidl_stream_buffer_return.val.getDiscriminator() ==
-      StreamBuffersVal::hidl_discriminator::error) {
-    switch (hidl_stream_buffer_return.val.error()) {
+  if (aidl_stream_buffer_return.val.getTag() == Tag::error) {
+    switch (aidl_stream_buffer_return.val.get<Tag::error>()) {
       case StreamBufferRequestError::NO_BUFFER_AVAILABLE:
         hal_buffer_return->val.error =
             google_camera_hal::StreamBufferRequestError::kNoBufferAvailable;
@@ -1102,7 +1091,7 @@ status_t ConvertToHalBufferReturnStatus(
         break;
       default:
         ALOGE("%s: Unknown StreamBufferRequestError %d", __FUNCTION__,
-              hidl_stream_buffer_return.val.error());
+              aidl_stream_buffer_return.val.get<Tag::error>());
         return BAD_VALUE;
     }
   } else {
@@ -1113,40 +1102,20 @@ status_t ConvertToHalBufferReturnStatus(
   return OK;
 }
 
-status_t ConvertStreamConfigurationV34ToV37(
-    const device::V3_4::StreamConfiguration& config_3_4,
-    StreamConfiguration* config_3_7) {
-  if (config_3_7 == nullptr) {
-    ALOGE("%s: config_3_7 is nullptr.", __FUNCTION__);
-    return BAD_VALUE;
-  }
-
-  config_3_7->streams.resize(config_3_4.streams.size());
-  for (size_t i = 0; i < config_3_4.streams.size(); i++) {
-    config_3_7->streams[i].v3_4 = config_3_4.streams[i];
-    config_3_7->streams[i].groupId = -1;
-  }
-  config_3_7->operationMode = config_3_4.operationMode;
-  config_3_7->sessionParams = config_3_4.sessionParams;
-  config_3_7->multiResolutionInputImage = false;
-
-  return OK;
-}
-
 status_t ConvertToHalDeviceState(
-    const hardware::hidl_bitfield<DeviceState> hidl_device_state,
+    int64_t aidl_device_state,
     google_camera_hal::DeviceState& hal_device_state) {
-  switch (static_cast<DeviceState>(hidl_device_state)) {
-    case DeviceState::NORMAL:
+  switch (aidl_device_state) {
+    case ICameraProvider::DEVICE_STATE_NORMAL:
       hal_device_state = google_camera_hal::DeviceState::kNormal;
       break;
-    case DeviceState::BACK_COVERED:
+    case ICameraProvider::DEVICE_STATE_BACK_COVERED:
       hal_device_state = google_camera_hal::DeviceState::kBackCovered;
       break;
-    case DeviceState::FRONT_COVERED:
+    case ICameraProvider::DEVICE_STATE_FRONT_COVERED:
       hal_device_state = google_camera_hal::DeviceState::kFrontCovered;
       break;
-    case DeviceState::FOLDED:
+    case ICameraProvider::DEVICE_STATE_FOLDED:
       hal_device_state = google_camera_hal::DeviceState::kFolded;
       break;
     default:
@@ -1156,7 +1125,8 @@ status_t ConvertToHalDeviceState(
 
   return OK;
 }
-}  // namespace hidl_utils
+
+}  // namespace aidl_utils
 }  // namespace implementation
 }  // namespace camera
 }  // namespace hardware
diff --git a/common/hal/aidl_service/aidl_utils.h b/common/hal/aidl_service/aidl_utils.h
new file mode 100644
index 0000000..05873f3
--- /dev/null
+++ b/common/hal/aidl_service/aidl_utils.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_UTILS_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_UTILS_H_
+
+#include <aidl/android/hardware/camera/common/CameraMetadataType.h>
+#include <aidl/android/hardware/camera/common/Status.h>
+#include <aidl/android/hardware/camera/device/ICameraDevice.h>
+#include <aidl/android/hardware/camera/provider/ICameraProvider.h>
+#include <aidlcommonsupport/NativeHandle.h>
+/*#include <android/hardware/camera/common/1.0/types.h>
+#include <android/hardware/camera/device/3.7/ICameraDeviceSession.h>
+#include <android/hardware/camera/device/3.8/types.h>*/
+#include <fmq/AidlMessageQueue.h>
+#include <fmq/MessageQueue.h>
+#include <hal_types.h>
+
+#include <memory>
+
+#include "aidl_camera_provider.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace implementation {
+namespace aidl_utils {
+
+using aidl::android::hardware::camera::common::CameraDeviceStatus;
+using aidl::android::hardware::camera::common::CameraMetadataType;
+using aidl::android::hardware::camera::common::CameraResourceCost;
+using aidl::android::hardware::camera::common::Status;
+using aidl::android::hardware::camera::common::TorchModeStatus;
+using aidl::android::hardware::camera::common::VendorTagSection;
+using aidl::android::hardware::camera::device::BufferCache;
+using aidl::android::hardware::camera::device::BufferRequest;
+using aidl::android::hardware::camera::device::BufferRequestStatus;
+using aidl::android::hardware::camera::device::BufferStatus;
+using aidl::android::hardware::camera::device::CaptureRequest;
+using aidl::android::hardware::camera::device::CaptureResult;
+using aidl::android::hardware::camera::device::ErrorCode;
+using aidl::android::hardware::camera::device::ErrorMsg;
+using aidl::android::hardware::camera::device::HalStream;
+using aidl::android::hardware::camera::device::NotifyMsg;
+using aidl::android::hardware::camera::device::RequestTemplate;
+using aidl::android::hardware::camera::device::ShutterMsg;
+using aidl::android::hardware::camera::device::Stream;
+using aidl::android::hardware::camera::device::StreamBuffer;
+using aidl::android::hardware::camera::device::StreamBufferRequestError;
+using aidl::android::hardware::camera::device::StreamBufferRet;
+using aidl::android::hardware::camera::device::StreamBuffersVal;
+using aidl::android::hardware::camera::device::StreamConfiguration;
+using aidl::android::hardware::camera::device::StreamConfigurationMode;
+using aidl::android::hardware::camera::device::StreamRotation;
+using aidl::android::hardware::camera::device::StreamType;
+using aidl::android::hardware::camera::provider::ICameraProvider;
+using aidl::android::hardware::common::NativeHandle;
+using aidl::android::hardware::common::fmq::SynchronizedReadWrite;
+
+using ndk::ScopedAStatus;
+
+// Util functions to convert the types between AIDL and Google Camera HAL.
+
+// Conversions from HAL to AIDL
+
+ScopedAStatus ConvertToAidlReturn(status_t hal_status);
+
+status_t ConvertToAidlVendorTagSections(
+    const std::vector<google_camera_hal::VendorTagSection>& hal_sections,
+    std::vector<VendorTagSection>* aidl_sections);
+
+status_t ConvertToAidlVendorTagType(
+    google_camera_hal::CameraMetadataType hal_type,
+    CameraMetadataType* aidl_type);
+
+status_t ConvertToAidlResourceCost(
+    const google_camera_hal::CameraResourceCost& hal_cost,
+    CameraResourceCost* aidl_cost);
+
+status_t ConvertToAidlHalStreamConfig(
+    const std::vector<google_camera_hal::HalStream>& hal_configured_streams,
+    std::vector<HalStream>* aidl_hal_stream_config);
+
+status_t ConverToAidlNotifyMessage(
+    const google_camera_hal::NotifyMessage& hal_message,
+    NotifyMsg* aidl_message);
+
+// Convert from HAL CameraDeviceStatus to AIDL CameraDeviceStatus
+// kNotPresent is converted to CameraDeviceStatus::NOT_PRESENT.
+// kPresent is converted to CameraDeviceStatus::PRESENT.
+// kEnumerating is converted to CameraDeviceStatus::ENUMERATING.
+status_t ConvertToAidlCameraDeviceStatus(
+    google_camera_hal::CameraDeviceStatus hal_camera_device_status,
+    CameraDeviceStatus* aidl_camera_device_status);
+
+// Convert from HAL TorchModeStatus to AIDL TorchModeStatus
+// kNotAvailable is converted to TorchModeStatus::NOT_AVAILABLE.
+// kAvailableOff is converted to TorchModeStatus::AVAILABLE_OFF.
+// kAvailableOn is converted to TorchModeStatus::AVAILABLE_ON.
+status_t ConvertToAidlTorchModeStatus(
+    google_camera_hal::TorchModeStatus hal_torch_status,
+    TorchModeStatus* aidl_torch_status);
+
+// Convert a HAL request to a AIDL request.
+status_t ConvertToAidlBufferRequest(
+    const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
+    std::vector<BufferRequest>* aidl_buffer_requests);
+
+status_t ConvertToHalBufferStatus(BufferStatus aidl_status,
+                                  google_camera_hal::BufferStatus* hal_status);
+
+// Convert a HAL result to a AIDL result. It will try to write the result
+// metadata to result_metadata_queue. If it fails, it will write the result
+// metadata in aidl_result.
+status_t ConvertToAidlCaptureResult(
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* result_metadata_queue,
+    std::unique_ptr<google_camera_hal::CaptureResult> hal_result,
+    CaptureResult* aidl_result);
+
+// Convert a HAL stream buffer to a AIDL aidl stream buffer.
+status_t ConvertToAidlStreamBuffer(
+    const google_camera_hal::StreamBuffer& hal_buffer,
+    StreamBuffer* aidl_buffer);
+
+// Conversions from AIDL to HAL.
+status_t ConvertToHalTemplateType(
+    RequestTemplate aidl_template,
+    google_camera_hal::RequestTemplate* hal_template);
+
+bool IsAidlNativeHandleNull(const NativeHandle& handle);
+
+status_t ConvertToHalStreamBuffer(
+    const StreamBuffer& aidl_buffer, google_camera_hal::StreamBuffer* hal_buffer,
+    std::vector<native_handle_t*>* handles_to_delete);
+
+status_t ConvertToHalMetadata(
+    uint32_t message_queue_setting_size,
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* request_metadata_queue,
+    const std::vector<uint8_t>& request_settings,
+    std::unique_ptr<google_camera_hal::HalCameraMetadata>* hal_metadata);
+
+status_t ConvertToHalCaptureRequest(
+    const CaptureRequest& aidl_request,
+    AidlMessageQueue<int8_t, SynchronizedReadWrite>* request_metadata_queue,
+    google_camera_hal::CaptureRequest* hal_request,
+    std::vector<native_handle_t*>* native_handles_to_delete);
+
+status_t ConvertToHalBufferCaches(
+    const std::vector<BufferCache>& aidl_buffer_caches,
+    std::vector<google_camera_hal::BufferCache>* hal_buffer_caches);
+
+status_t ConvertToHalStreamConfig(
+    const StreamConfiguration& aidl_stream_config,
+    google_camera_hal::StreamConfiguration* hal_stream_config);
+
+status_t ConvertToHalStreamConfigurationMode(
+    StreamConfigurationMode aidl_mode,
+    google_camera_hal::StreamConfigurationMode* hal_mode);
+
+status_t ConvertToHalStream(const Stream& aidl_stream,
+                            google_camera_hal::Stream* hal_stream);
+
+status_t ConvertToHalStreamRotation(
+    StreamRotation aidl_stream_rotation,
+    google_camera_hal::StreamRotation* hal_stream_rotation);
+
+status_t ConvertToHalStreamType(StreamType aidl_stream_type,
+                                google_camera_hal::StreamType* hal_stream_type);
+
+status_t ConvertToHalBufferRequestStatus(
+    const BufferRequestStatus& aidl_buffer_request_status,
+    google_camera_hal::BufferRequestStatus* hal_buffer_request_status);
+
+status_t ConvertToHalBufferReturnStatus(
+    const StreamBufferRet& aidl_stream_buffer_return,
+    google_camera_hal::BufferReturn* hal_buffer_return);
+
+status_t ConvertToHalDeviceState(
+    const int64_t aidl_device_state,
+    google_camera_hal::DeviceState& hal_device_state);
+
+}  // namespace aidl_utils
+}  // namespace implementation
+}  // namespace camera
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_AIDL_SERVICE_AIDL_UTILS_H_
diff --git a/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc
new file mode 100644
index 0000000..423a708
--- /dev/null
+++ b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc
@@ -0,0 +1,10 @@
+service vendor.camera-provider-2-7-google /vendor/bin/hw/android.hardware.camera.provider@2.7-service-google-lazy
+    interface aidl android.hardware.camera.provider.ICameraProvider/internal/0
+    oneshot
+    disabled
+    class hal
+    user system
+    group system
+    capabilities SYS_NICE
+    rlimit rtprio 10 10
+    task_profiles CameraServiceCapacity CameraServicePerformance
diff --git a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google.rc b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.rc
index b5cfab5..b5cfab5 100644
--- a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google.rc
+++ b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.rc
diff --git a/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml
new file mode 100644
index 0000000..5e74ac5
--- /dev/null
+++ b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml
@@ -0,0 +1,10 @@
+<manifest version="1.0" type="device">
+    <hal format="aidl">
+        <name>android.hardware.camera.provider</name>
+        <version>1</version>
+        <interface>
+            <name>ICameraProvider</name>
+            <instance>internal/0</instance>
+        </interface>
+    </hal>
+</manifest>
diff --git a/common/hal/hidl_service/hidl_thermal_utils.cc b/common/hal/aidl_service/hidl_thermal_utils.cc
index 578371b..cb2c915 100644
--- a/common/hal/hidl_service/hidl_thermal_utils.cc
+++ b/common/hal/aidl_service/hidl_thermal_utils.cc
@@ -16,17 +16,14 @@
 
 #define LOG_TAG "GCH_HidlThermalUtils"
 //#define LOG_NDEBUG 0
-#include <log/log.h>
-
 #include "hidl_thermal_utils.h"
-#include "hidl_utils.h"
+
+#include <log/log.h>
 
 namespace android {
 namespace hardware {
 namespace hidl_thermal_utils {
 
-namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
-
 std::unique_ptr<HidlThermalChangedCallback> HidlThermalChangedCallback::Create(
     google_camera_hal::NotifyThrottlingFunc notify_throttling) {
   auto thermal_changed_callback = std::unique_ptr<HidlThermalChangedCallback>(
diff --git a/common/hal/hidl_service/hidl_thermal_utils.h b/common/hal/aidl_service/hidl_thermal_utils.h
index d815ab2..d815ab2 100644
--- a/common/hal/hidl_service/hidl_thermal_utils.h
+++ b/common/hal/aidl_service/hidl_thermal_utils.h
diff --git a/common/hal/hidl_service/libc_wrappers.cc b/common/hal/aidl_service/libc_wrappers.cc
index 45b260b..3534fa8 100644
--- a/common/hal/hidl_service/libc_wrappers.cc
+++ b/common/hal/aidl_service/libc_wrappers.cc
@@ -3,6 +3,7 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+
 #include <string>
 #include <unordered_map>
 
@@ -171,18 +172,24 @@ extern "C" int openat(int dirfd, const char* pathname, int flags, ...) {
 }
 #endif
 
-using dlopen_function_type = void* (*)(const char*, int);
+using __loader_dlopen_function_type = void* (*)(const char* filename, int flags,
+                                                const void* caller_addr);
 
 // This is a temporary workaround for prebuilts calling dlopen with absolute
-// paths.
-extern "C" void* dlopen(const char* filename, int flags) {
-  static auto real_dlopen_function =
-      reinterpret_cast<dlopen_function_type>(dlsym(RTLD_NEXT, "dlopen"));
-  if (!real_dlopen_function) {
-    ALOGE("Could not RTLD_NEXT dlopen, something very wrong.");
+// paths. We interpose __loader_dlopen instead of dlopen because dlopen calls
+// __builtin_return_address to determine the linker namespace. We need
+// caller_addr to point to the original caller and not "this" lib for the case
+// of system libs that use dlopen.
+extern "C" void* __loader_dlopen(const char* filename, int flags,
+                                 const void* caller_addr) {
+  static auto real__loader_dlopen_function =
+      reinterpret_cast<__loader_dlopen_function_type>(
+          dlsym(RTLD_NEXT, "__loader_dlopen"));
+  if (!real__loader_dlopen_function) {
+    ALOGE("Could not RTLD_NEXT __loader_dlopen, something very wrong.");
     std::abort();
   }
-  void* ret = real_dlopen_function(filename, flags);
+  void* ret = real__loader_dlopen_function(filename, flags, caller_addr);
   if (!ret) {
     ALOGI("dlopen(%s) failed, seeing if we can fix it", filename);
     std::string original_filename(filename);
@@ -191,7 +198,8 @@ extern "C" void* dlopen(const char* filename, int flags) {
       std::string new_filename = "/apex/com.google.pixel.camera.hal/" +
                                  original_filename.substr(strlen("/vendor/"));
       ALOGI("Trying %s instead of %s\n", new_filename.c_str(), filename);
-      ret = real_dlopen_function(new_filename.c_str(), flags);
+      ret = real__loader_dlopen_function(new_filename.c_str(), flags,
+                                         caller_addr);
       if (ret) {
         ALOGE(
             "ERROR: Update your code to not use absolute paths. dlopen(%s) "
diff --git a/common/hal/hidl_service/version_script.py b/common/hal/aidl_service/version_script.py
index 882b85c..5551ad9 100644
--- a/common/hal/hidl_service/version_script.py
+++ b/common/hal/aidl_service/version_script.py
@@ -20,7 +20,7 @@ import os
 import re
 import sys
 
-BRANCH_SPECIFIC_VERSION_IDENTIFIER = 3  # sc-v2
+BRANCH_SPECIFIC_VERSION_IDENTIFIER = 4  # main
 DEFAULT_ENG_BUILD_NUMBER = 2147480000
 DEFAULT_BAD_BUILD_NUMBER = DEFAULT_ENG_BUILD_NUMBER - 1
 
diff --git a/common/hal/common/hal_types.h b/common/hal/common/hal_types.h
index 3563e94..7c18b34 100644
--- a/common/hal/common/hal_types.h
+++ b/common/hal/common/hal_types.h
@@ -106,7 +106,7 @@ enum class StreamRotation : uint32_t {
 };
 
 // See the definition of
-// ::android::hardware::camera::device::V3_7::Stream;
+// ::android::hardware::camera::device::V3_8::Stream;
 struct Stream {
   int32_t id = -1;
   StreamType stream_type = StreamType::kOutput;
@@ -122,6 +122,11 @@ struct Stream {
   int32_t group_id = -1;
   bool used_in_max_resolution_mode = false;
   bool used_in_default_resolution_mode = true;
+  camera_metadata_enum_android_request_available_dynamic_range_profiles_map
+      dynamic_profile =
+          ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
+  camera_metadata_enum_android_scaler_available_stream_use_cases use_case =
+      ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT;
 };
 
 // See the definition of
@@ -132,7 +137,7 @@ enum class StreamConfigurationMode : uint32_t {
 };
 
 // See the definition of
-// ::android::hardware::camera::device::V3_7::StreamConfiguration;
+// ::android::hardware::camera::device::V3_8::StreamConfiguration;
 struct StreamConfiguration {
   std::vector<Stream> streams;
   StreamConfigurationMode operation_mode;
@@ -253,14 +258,15 @@ struct ErrorMessage {
 };
 
 // See the definition of
-// ::android::hardware::camera::device::V3_2::ShutterMsg
+// ::android::hardware::camera::device::V3_8::ShutterMsg
 struct ShutterMessage {
   uint32_t frame_number = 0;
   uint64_t timestamp_ns = 0;
+  uint64_t readout_timestamp_ns = 0;
 };
 
 // See the definition of
-// ::android::hardware::camera::device::V3_2::NotifyMsg
+// ::android::hardware::camera::device::V3_8::NotifyMsg
 struct NotifyMessage {
   MessageType type = MessageType::kError;
 
diff --git a/common/hal/common/vendor_tag_defs.h b/common/hal/common/vendor_tag_defs.h
index eef389d..8b7c6ce 100644
--- a/common/hal/common/vendor_tag_defs.h
+++ b/common/hal/common/vendor_tag_defs.h
@@ -47,6 +47,7 @@ enum VendorTagIds : uint32_t {
   kNonWarpedCropRegion,
   kHdrUsageMode,
   kSwDenoiseEnabled,
+  kVideoSwDenoiseEnabled,
   // This should not be used as a vendor tag ID on its own, but as a placeholder
   // to indicate the end of currently defined vendor tag IDs
   kEndMarker
@@ -66,7 +67,12 @@ enum class SmoothyMode : uint32_t {
 
   // Uses UW camera with a larger margin. In this way, we get a better video
   // stabilization quality, while preserving a similar FoV as the main camera.
-  kSuperstabMode
+  kSuperstabMode,
+
+  // Tracks an object of interest with a frame delay. For example, tracking is
+  // done at app side which is N frame later than HAL where N is the pipeline
+  // depth.
+  kDelayedTrackingMode,
 };
 
 // Logical camera vendor tags
@@ -214,6 +220,15 @@ static const std::vector<VendorTag> kInternalVendorTags = {
     {.tag_id = VendorTagIds::kSwDenoiseEnabled,
      .tag_name = "SwDenoiseEnabled",
      .tag_type = CameraMetadataType::kByte},
+    // Video software denoise enabled
+    //
+    // Indicates whether the software denoise for video is enabled
+    //
+    // Present in: Characteristics
+    // Payload: VideoSwDenoiseEnabled
+    {.tag_id = VendorTagIds::kVideoSwDenoiseEnabled,
+     .tag_name = "VideoSwDenoiseEnabled",
+     .tag_type = CameraMetadataType::kByte},
 };
 
 // Google Camera HAL vendor tag sections
diff --git a/common/hal/google_camera_hal/Android.bp b/common/hal/google_camera_hal/Android.bp
index 3850283..59640ea 100644
--- a/common/hal/google_camera_hal/Android.bp
+++ b/common/hal/google_camera_hal/Android.bp
@@ -70,6 +70,7 @@ cc_library_shared {
         "realtime_process_block.cc",
         "realtime_zsl_request_processor.cc",
         "realtime_zsl_result_processor.cc",
+        "realtime_zsl_result_request_processor.cc",
         "rgbird_capture_session.cc",
         "rgbird_depth_result_processor.cc",
         "rgbird_result_request_processor.cc",
@@ -96,6 +97,7 @@ cc_library_shared {
     ],
     header_libs: [
         "lib_depth_generator_headers",
+        "libgooglecamerahal_headers",
     ],
     // b/129863492, clang-tidy nondeterministic seg fault
     tidy: false,
diff --git a/common/hal/google_camera_hal/camera_device.cc b/common/hal/google_camera_hal/camera_device.cc
index fba579a..55c3a41 100644
--- a/common/hal/google_camera_hal/camera_device.cc
+++ b/common/hal/google_camera_hal/camera_device.cc
@@ -167,6 +167,21 @@ status_t CameraDevice::Initialize(
     return res;
   }
 
+  std::unique_ptr<HalCameraMetadata> static_metadata;
+  res = camera_device_hwl_->GetCameraCharacteristics(&static_metadata);
+  if (res != OK) {
+    ALOGE("%s: Getting camera characteristics failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return res;
+  }
+
+  res = utils::GetStreamUseCases(static_metadata.get(), &stream_use_cases_);
+  if (res != OK) {
+    ALOGE("%s: Getting stream use cases failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return res;
+  }
+
   return OK;
 }
 
@@ -208,6 +223,23 @@ status_t CameraDevice::SetTorchMode(TorchMode mode) {
   return camera_device_hwl_->SetTorchMode(mode);
 }
 
+status_t CameraDevice::TurnOnTorchWithStrengthLevel(int32_t torch_strength) {
+  ATRACE_CALL();
+  return camera_device_hwl_->TurnOnTorchWithStrengthLevel(torch_strength);
+}
+
+status_t CameraDevice::GetTorchStrengthLevel(int32_t& torch_strength) const {
+  ATRACE_CALL();
+  status_t res = camera_device_hwl_->GetTorchStrengthLevel(torch_strength);
+  if (res != OK) {
+    ALOGE("%s: GetTorchStrengthLevel() failed: %s (%d).", __FUNCTION__,
+          strerror(-res), res);
+    return res;
+  }
+
+  return res;
+}
+
 status_t CameraDevice::DumpState(int fd) {
   ATRACE_CALL();
   return camera_device_hwl_->DumpState(fd);
@@ -247,6 +279,10 @@ status_t CameraDevice::CreateCameraDeviceSession(
 
 bool CameraDevice::IsStreamCombinationSupported(
     const StreamConfiguration& stream_config) {
+  if (!utils::IsStreamUseCaseSupported(stream_config, stream_use_cases_)) {
+    return false;
+  }
+
   bool supported =
       camera_device_hwl_->IsStreamCombinationSupported(stream_config);
   if (!supported) {
@@ -307,10 +343,7 @@ CameraDevice::~CameraDevice() {
 
 std::unique_ptr<google::camera_common::Profiler> CameraDevice::GetProfiler(
     uint32_t camera_id, int option) {
-  if (option & google::camera_common::Profiler::SetPropFlag::kCustomProfiler) {
-    return camera_device_hwl_->GetProfiler(camera_id, option);
-  }
-  return nullptr;
+  return camera_device_hwl_->GetProfiler(camera_id, option);
 }
 
 }  // namespace google_camera_hal
diff --git a/common/hal/google_camera_hal/camera_device.h b/common/hal/google_camera_hal/camera_device.h
index 8edcbd7..80245f1 100644
--- a/common/hal/google_camera_hal/camera_device.h
+++ b/common/hal/google_camera_hal/camera_device.h
@@ -62,6 +62,13 @@ class CameraDevice {
   // unchanged after this CameraDevice instance is destroyed.
   status_t SetTorchMode(TorchMode mode);
 
+  // Change the brightness level of the flash unit in Torch mode.
+  // If the torch is OFF and torchStrength > 0, the torch will be turned ON.
+  status_t TurnOnTorchWithStrengthLevel(int32_t torch_strength);
+
+  // Get the flash unit strength level of this camera device.
+  status_t GetTorchStrengthLevel(int32_t& torch_strength) const;
+
   // Create a CameraDeviceSession to handle capture requests. This method will
   // return ALREADY_EXISTS if previous session has not been destroyed.
   // Created CameraDeviceSession remain valid even after this CameraDevice
@@ -103,6 +110,8 @@ class CameraDevice {
   std::vector<GetCaptureSessionFactoryFunc> external_session_factory_entries_;
   // Opened library handles that should be closed on destruction
   std::vector<void*> external_capture_session_lib_handles_;
+  // Stream use cases supported by this camera device
+  std::set<int64_t> stream_use_cases_;
 
   const std::vector<std::string>* configure_streams_libs_ = nullptr;
 };
diff --git a/common/hal/google_camera_hal/camera_device_session.cc b/common/hal/google_camera_hal/camera_device_session.cc
index 0b690b6..f1821e6 100644
--- a/common/hal/google_camera_hal/camera_device_session.cc
+++ b/common/hal/google_camera_hal/camera_device_session.cc
@@ -431,6 +431,13 @@ status_t CameraDeviceSession::Initialize(
     return res;
   }
 
+  res = utils::GetStreamUseCases(characteristics.get(), &stream_use_cases_);
+  if (res != OK) {
+    ALOGE("%s: Initializing stream use case failed: %s(%d)", __FUNCTION__,
+          strerror(-res), res);
+    return res;
+  }
+
   res = InitializeBufferManagement(characteristics.get());
   if (res != OK) {
     ALOGE("%s: Initialize buffer management failed: %s(%d)", __FUNCTION__,
@@ -689,6 +696,15 @@ status_t CameraDeviceSession::ConfigureStreams(
   operation_mode_ = stream_config.operation_mode;
   multi_res_reprocess_ = stream_config.multi_resolution_input_image;
 
+  // TODO: We would ideally want this to be a part of CreateCaptureSession,
+  // which internally calls IsStreamCombinationSupported. However this
+  // IsStreamCombinationSupported doesn't match the
+  // CameraDevice::IsStreamCombination. We should look at unifying the two for a
+  // potentially cleaner code-base.
+  if (!utils::IsStreamUseCaseSupported(stream_config, stream_use_cases_)) {
+    return BAD_VALUE;
+  }
+
   capture_session_ = CreateCaptureSession(
       stream_config, kWrapperCaptureSessionEntries,
       external_capture_session_entries_, kCaptureSessionEntries,
@@ -1416,6 +1432,8 @@ void CameraDeviceSession::RemoveBufferCache(
       }
     };
 
+    device_session_hwl_->RemoveCachedBuffers(buffer_handle_it->second);
+
     if (buffer_mapper_v4_ != nullptr) {
       free_buffer_mapper(buffer_mapper_v4_);
     } else if (buffer_mapper_v3_ != nullptr) {
diff --git a/common/hal/google_camera_hal/camera_device_session.h b/common/hal/google_camera_hal/camera_device_session.h
index b2b0fda..768cf26 100644
--- a/common/hal/google_camera_hal/camera_device_session.h
+++ b/common/hal/google_camera_hal/camera_device_session.h
@@ -423,6 +423,9 @@ class CameraDeviceSession {
   // Protected by request_record_lock_;
   std::set<uint32_t> ignore_shutters_;
 
+  // Stream use cases supported by this camera device
+  std::set<int64_t> stream_use_cases_;
+
   static constexpr int32_t kInvalidStreamId = -1;
 
   // Whether measure the time of buffer allocation
diff --git a/common/hal/google_camera_hal/camera_provider.cc b/common/hal/google_camera_hal/camera_provider.cc
index e3f5e85..2d816eb 100644
--- a/common/hal/google_camera_hal/camera_provider.cc
+++ b/common/hal/google_camera_hal/camera_provider.cc
@@ -318,15 +318,15 @@ status_t CameraProvider::CreateHwl(
   }
 
   // Create the HWL camera provider
-  *camera_provider_hwl = std::unique_ptr<CameraProviderHwl>(create_hwl());
+  camera_provider_hwl->reset(create_hwl());
+#else
+  camera_provider_hwl->reset(CreateCameraProviderHwl());
+#endif
+
   if (*camera_provider_hwl == nullptr) {
     ALOGE("Error! Creating CameraProviderHwl failed");
     return UNKNOWN_ERROR;
   }
-#else
-  *camera_provider_hwl =
-      std::unique_ptr<CameraProviderHwl>(CreateCameraProviderHwl());
-#endif
 
   return OK;
 }
diff --git a/common/hal/google_camera_hal/hdrplus_capture_session.cc b/common/hal/google_camera_hal/hdrplus_capture_session.cc
index 4e05d13..c7b676a 100644
--- a/common/hal/google_camera_hal/hdrplus_capture_session.cc
+++ b/common/hal/google_camera_hal/hdrplus_capture_session.cc
@@ -653,9 +653,10 @@ void HdrplusCaptureSession::NotifyHalMessage(const NotifyMessage& message) {
   }
 
   if (message.type == MessageType::kShutter) {
-    status_t res =
-        result_dispatcher_->AddShutter(message.message.shutter.frame_number,
-                                       message.message.shutter.timestamp_ns);
+    status_t res = result_dispatcher_->AddShutter(
+        message.message.shutter.frame_number,
+        message.message.shutter.timestamp_ns,
+        message.message.shutter.readout_timestamp_ns);
     if (res != OK) {
       ALOGE("%s: AddShutter for frame %u failed: %s (%d).", __FUNCTION__,
             message.message.shutter.frame_number, strerror(-res), res);
diff --git a/common/hal/google_camera_hal/hdrplus_capture_session.h b/common/hal/google_camera_hal/hdrplus_capture_session.h
index 2519541..8369196 100644
--- a/common/hal/google_camera_hal/hdrplus_capture_session.h
+++ b/common/hal/google_camera_hal/hdrplus_capture_session.h
@@ -33,7 +33,7 @@ namespace google_camera_hal {
 // process chains (realtime and HDR+)
 //
 // 1. RealtimeZslRequestProcessor -> RealtimeProcessBlock ->
-//    RealtimeZslResultProcessor
+//    RealtimeZslResultRequestProcessor
 // 2. HdrplusRequestProcessor -> HdrplusProcessBlock -> HdrplusResultProcessor
 //
 // It only supports a single physical camera device session.
diff --git a/common/hal/google_camera_hal/realtime_zsl_result_processor.cc b/common/hal/google_camera_hal/realtime_zsl_result_processor.cc
index d337f88..0475c46 100644
--- a/common/hal/google_camera_hal/realtime_zsl_result_processor.cc
+++ b/common/hal/google_camera_hal/realtime_zsl_result_processor.cc
@@ -15,16 +15,16 @@
  */
 
 //#define LOG_NDEBUG 0
+#include "hal_types.h"
 #define LOG_TAG "GCH_RealtimeZslResultProcessor"
 #define ATRACE_TAG ATRACE_TAG_CAMERA
 
-#include "realtime_zsl_result_processor.h"
-
 #include <inttypes.h>
 #include <log/log.h>
 #include <utils/Trace.h>
 
 #include "hal_utils.h"
+#include "realtime_zsl_result_processor.h"
 
 namespace android {
 namespace google_camera_hal {
@@ -249,6 +249,7 @@ void RealtimeZslResultProcessor::ProcessResult(ProcessBlockResult block_result)
       result->output_buffers.size() == 0) {
     return;
   }
+
   process_capture_result_(std::move(result));
 }
 
diff --git a/common/hal/google_camera_hal/realtime_zsl_result_processor.h b/common/hal/google_camera_hal/realtime_zsl_result_processor.h
index 3a59df2..61106e3 100644
--- a/common/hal/google_camera_hal/realtime_zsl_result_processor.h
+++ b/common/hal/google_camera_hal/realtime_zsl_result_processor.h
@@ -17,15 +17,16 @@
 #ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_PROCESSOR_H_
 #define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_PROCESSOR_H_
 
+#include <shared_mutex>
+
 #include "internal_stream_manager.h"
 #include "result_processor.h"
 
 namespace android {
 namespace google_camera_hal {
 
-// RealtimeZslResultProcessor implements a ResultProcessor that return filled
-// raw buffer and matedata to internal stream manager and forwards the results
-// without raw buffer to its callback functions.
+// RealtimeZslResultProcessor implements a ResultProcessor that return
+// filled raw buffer and metadata to internal stream manager.
 class RealtimeZslResultProcessor : public ResultProcessor {
  public:
   static std::unique_ptr<RealtimeZslResultProcessor> Create(
@@ -42,7 +43,7 @@ class RealtimeZslResultProcessor : public ResultProcessor {
       const std::vector<ProcessBlockRequest>& process_block_requests,
       const CaptureRequest& remaining_session_request) override;
 
-  // Return filled raw buffer and matedata to internal stream manager
+  // Return filled raw buffer and metadata to internal stream manager
   // and forwards the results without raw buffer to its callback functions.
   void ProcessResult(ProcessBlockResult block_result) override;
 
@@ -57,6 +58,17 @@ class RealtimeZslResultProcessor : public ResultProcessor {
                              android_pixel_format_t pixel_format,
                              uint32_t partial_result_count);
 
+  InternalStreamManager* internal_stream_manager_;
+  int32_t stream_id_ = -1;
+  // Partial result count reported by HAL
+  uint32_t partial_result_count_;
+
+  std::mutex callback_lock_;
+
+  // The following callbacks must be protected by callback_lock_.
+  ProcessCaptureResultFunc process_capture_result_;
+  NotifyFunc notify_;
+
  private:
   // Save face detect mode for HDR+
   void SaveFdForHdrplus(const CaptureRequest& request);
@@ -68,14 +80,7 @@ class RealtimeZslResultProcessor : public ResultProcessor {
   // Handle Lens shading metadata from result for HDR+
   status_t HandleLsResultForHdrplus(uint32_t frameNumber,
                                     HalCameraMetadata* metadata);
-  std::mutex callback_lock_;
-
-  // The following callbacks must be protected by callback_lock_.
-  ProcessCaptureResultFunc process_capture_result_;
-  NotifyFunc notify_;
 
-  InternalStreamManager* internal_stream_manager_;
-  int32_t stream_id_ = -1;
   android_pixel_format_t pixel_format_;
 
   // Current face detect mode set by framework.
@@ -97,11 +102,10 @@ class RealtimeZslResultProcessor : public ResultProcessor {
   // lens_shading_lock_
   std::unordered_map<uint32_t, uint8_t> requested_lens_shading_map_modes_;
 
-  // Partial result count reported by HAL
-  uint32_t partial_result_count_;
+  std::shared_mutex process_block_shared_lock_;
 };
 
 }  // namespace google_camera_hal
 }  // namespace android
 
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_PROCESSOR_H_
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_REQUEST_PROCESSOR_H_
diff --git a/common/hal/google_camera_hal/realtime_zsl_result_request_processor.cc b/common/hal/google_camera_hal/realtime_zsl_result_request_processor.cc
new file mode 100644
index 0000000..23b9f78
--- /dev/null
+++ b/common/hal/google_camera_hal/realtime_zsl_result_request_processor.cc
@@ -0,0 +1,342 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// #define LOG_NDEBUG 0
+#define LOG_TAG "GCH_RealtimeZslResultRequestProcessor"
+#define ATRACE_TAG ATRACE_TAG_CAMERA
+
+#include "realtime_zsl_result_request_processor.h"
+
+#include <inttypes.h>
+#include <log/log.h>
+#include <utils/Trace.h>
+
+#include "hal_types.h"
+#include "hal_utils.h"
+#include "realtime_zsl_result_processor.h"
+
+namespace android {
+namespace google_camera_hal {
+
+bool RealtimeZslResultRequestProcessor::AllDataCollected(
+    const RequestEntry& request_entry) const {
+  return request_entry.zsl_buffer_received &&
+         request_entry.framework_buffer_count ==
+             static_cast<int>(
+                 request_entry.capture_request->output_buffers.size()) &&
+         request_entry.partial_results_received == partial_result_count_;
+}
+
+std::unique_ptr<RealtimeZslResultRequestProcessor>
+RealtimeZslResultRequestProcessor::Create(
+    InternalStreamManager* internal_stream_manager, int32_t stream_id,
+    android_pixel_format_t pixel_format, uint32_t partial_result_count) {
+  ATRACE_CALL();
+  if (internal_stream_manager == nullptr) {
+    ALOGE("%s: internal_stream_manager is nullptr.", __FUNCTION__);
+    return nullptr;
+  }
+
+  auto result_processor = std::unique_ptr<RealtimeZslResultRequestProcessor>(
+      new RealtimeZslResultRequestProcessor(internal_stream_manager, stream_id,
+                                            pixel_format, partial_result_count));
+  if (result_processor == nullptr) {
+    ALOGE("%s: Creating RealtimeZslResultRequestProcessor failed.",
+          __FUNCTION__);
+    return nullptr;
+  }
+
+  return result_processor;
+}
+
+RealtimeZslResultRequestProcessor::RealtimeZslResultRequestProcessor(
+    InternalStreamManager* internal_stream_manager, int32_t stream_id,
+    android_pixel_format_t pixel_format, uint32_t partial_result_count)
+    : RealtimeZslResultProcessor(internal_stream_manager, stream_id,
+                                 pixel_format, partial_result_count) {
+}
+
+void RealtimeZslResultRequestProcessor::UpdateOutputBufferCount(
+    int32_t frame_number, int output_buffer_count) {
+  ATRACE_CALL();
+  std::lock_guard<std::mutex> lock(callback_lock_);
+  // Cache the CaptureRequest in a queue as the metadata and buffers may not
+  // come together.
+  RequestEntry request_entry = {
+      .capture_request = std::make_unique<CaptureRequest>(),
+      .framework_buffer_count = output_buffer_count};
+  request_entry.capture_request->frame_number = frame_number;
+
+  pending_frame_number_to_requests_[frame_number] = std::move(request_entry);
+}
+
+void RealtimeZslResultRequestProcessor::ProcessResult(
+    ProcessBlockResult block_result) {
+  ATRACE_CALL();
+  std::lock_guard<std::mutex> lock(callback_lock_);
+  std::unique_ptr<CaptureResult> result = std::move(block_result.result);
+  if (result == nullptr) {
+    ALOGW("%s: Received a nullptr result.", __FUNCTION__);
+    return;
+  }
+
+  // Pending request should always exist
+  RequestEntry& pending_request =
+      pending_frame_number_to_requests_[result->frame_number];
+
+  // Return filled raw buffer to internal stream manager
+  // And remove raw buffer from result
+  bool returned_output = false;
+  status_t res;
+  std::vector<StreamBuffer> modified_output_buffers;
+  for (uint32_t i = 0; i < result->output_buffers.size(); i++) {
+    if (stream_id_ == result->output_buffers[i].stream_id) {
+      returned_output = true;
+      res = internal_stream_manager_->ReturnFilledBuffer(
+          result->frame_number, result->output_buffers[i]);
+      if (res != OK) {
+        ALOGW("%s: (%d)ReturnStreamBuffer fail", __FUNCTION__,
+              result->frame_number);
+      }
+      pending_request.zsl_buffer_received = true;
+    } else {
+      modified_output_buffers.push_back(result->output_buffers[i]);
+    }
+  }
+
+  if (result->output_buffers.size() > 0) {
+    result->output_buffers.clear();
+    result->output_buffers = modified_output_buffers;
+  }
+
+  if (result->result_metadata) {
+    result->result_metadata->Erase(ANDROID_CONTROL_ENABLE_ZSL);
+
+    res = internal_stream_manager_->ReturnMetadata(
+        stream_id_, result->frame_number, result->result_metadata.get(),
+        result->partial_result);
+    if (res != OK) {
+      ALOGW("%s: (%d)ReturnMetadata fail", __FUNCTION__, result->frame_number);
+    }
+
+    if (result->partial_result == partial_result_count_) {
+      res =
+          hal_utils::SetEnableZslMetadata(result->result_metadata.get(), false);
+      if (res != OK) {
+        ALOGW("%s: SetEnableZslMetadata (%d) fail", __FUNCTION__,
+              result->frame_number);
+      }
+    }
+  }
+
+  // Return directly for frames with errors.
+  if (pending_error_frames_.find(result->frame_number) !=
+      pending_error_frames_.end()) {
+    RequestEntry& error_entry = pending_error_frames_[result->frame_number];
+    // Also need to process pending buffers and metadata for the frame if exists.
+    // If the result is complete (buffers and all partial results arrived), send
+    // the callback directly. Otherwise wait until the missing pieces arrive.
+    if (pending_request.zsl_buffer_received &&
+        pending_request.framework_buffer_count ==
+            static_cast<int>(
+                pending_request.capture_request->output_buffers.size())) {
+      result->output_buffers = pending_request.capture_request->output_buffers;
+      result->input_buffers = pending_request.capture_request->input_buffers;
+      error_entry.capture_request->output_buffers = result->output_buffers;
+      error_entry.capture_request->input_buffers = result->input_buffers;
+      error_entry.zsl_buffer_received = pending_request.zsl_buffer_received;
+      error_entry.framework_buffer_count =
+          pending_request.framework_buffer_count;
+    }
+    if (pending_request.capture_request->settings != nullptr) {
+      result->result_metadata = HalCameraMetadata::Clone(
+          pending_request.capture_request->settings.get());
+      result->partial_result = pending_request.partial_results_received;
+      error_entry.partial_results_received++;
+    }
+
+    // Reset capture request for pending request as all data has been
+    // transferred to error_entry already.
+    pending_request.capture_request = std::make_unique<CaptureRequest>();
+    pending_request.capture_request->frame_number = result->frame_number;
+
+    if (AllDataCollected(error_entry)) {
+      pending_error_frames_.erase(result->frame_number);
+      pending_frame_number_to_requests_.erase(result->frame_number);
+    }
+
+    // Don't send result to framework if only internal raw callback
+    if (returned_output && result->result_metadata == nullptr &&
+        result->output_buffers.size() == 0) {
+      return;
+    }
+    process_capture_result_(std::move(result));
+    return;
+  }
+
+  // Fill in final result metadata
+  if (result->result_metadata != nullptr) {
+    pending_request.partial_results_received++;
+    if (result->partial_result < partial_result_count_) {
+      // Early result, clone it
+      pending_request.capture_request->settings =
+          HalCameraMetadata::Clone(result->result_metadata.get());
+    } else {
+      // Final result, early result may or may not exist
+      if (pending_request.capture_request->settings == nullptr) {
+        // No early result, i.e. partial results disabled. Clone final result
+        pending_request.capture_request->settings =
+            HalCameraMetadata::Clone(result->result_metadata.get());
+      } else {
+        // Append final result to early result
+        pending_request.capture_request->settings->Append(
+            result->result_metadata->GetRawCameraMetadata());
+      }
+    }
+  }
+
+  // Fill in output buffers
+  if (!result->output_buffers.empty()) {
+    auto& output_buffers = pending_request.capture_request->output_buffers;
+    output_buffers.insert(output_buffers.begin(), result->output_buffers.begin(),
+                          result->output_buffers.end());
+  }
+
+  // Fill in input buffers
+  if (!result->input_buffers.empty()) {
+    auto& input_buffers = pending_request.capture_request->input_buffers;
+    input_buffers.insert(input_buffers.begin(), result->input_buffers.begin(),
+                         result->input_buffers.end());
+  }
+
+  // Submit the request and remove the request from the cache when all data is collected.
+  if (AllDataCollected(pending_request)) {
+    res = ProcessRequest(*pending_request.capture_request);
+    pending_frame_number_to_requests_.erase(result->frame_number);
+    if (res != OK) {
+      ALOGE("%s: ProcessRequest fail", __FUNCTION__);
+      return;
+    }
+  }
+}
+
+status_t RealtimeZslResultRequestProcessor::ConfigureStreams(
+    InternalStreamManager* /*internal_stream_manager*/,
+    const StreamConfiguration& stream_config,
+    StreamConfiguration* process_block_stream_config) {
+  ATRACE_CALL();
+  if (process_block_stream_config == nullptr) {
+    ALOGE("%s: process_block_stream_config is nullptr", __FUNCTION__);
+    return BAD_VALUE;
+  }
+
+  process_block_stream_config->streams = stream_config.streams;
+  process_block_stream_config->operation_mode = stream_config.operation_mode;
+  process_block_stream_config->session_params =
+      HalCameraMetadata::Clone(stream_config.session_params.get());
+  process_block_stream_config->stream_config_counter =
+      stream_config.stream_config_counter;
+  process_block_stream_config->multi_resolution_input_image =
+      stream_config.multi_resolution_input_image;
+
+  return OK;
+}
+
+status_t RealtimeZslResultRequestProcessor::SetProcessBlock(
+    std::unique_ptr<ProcessBlock> process_block) {
+  ATRACE_CALL();
+  if (process_block == nullptr) {
+    ALOGE("%s: process_block is nullptr", __FUNCTION__);
+    return BAD_VALUE;
+  }
+
+  std::lock_guard lock(process_block_shared_lock_);
+  if (process_block_ != nullptr) {
+    ALOGE("%s: Already configured.", __FUNCTION__);
+    return ALREADY_EXISTS;
+  }
+
+  process_block_ = std::move(process_block);
+  return OK;
+}
+
+status_t RealtimeZslResultRequestProcessor::ProcessRequest(
+    const CaptureRequest& request) {
+  ATRACE_CALL();
+  std::shared_lock lock(process_block_shared_lock_);
+  if (process_block_ == nullptr) {
+    ALOGE("%s: Not configured yet.", __FUNCTION__);
+    return NO_INIT;
+  }
+
+  CaptureRequest block_request;
+  block_request.frame_number = request.frame_number;
+  block_request.settings = HalCameraMetadata::Clone(request.settings.get());
+  block_request.input_buffers = request.input_buffers;
+  block_request.input_width = request.input_width;
+  block_request.input_height = request.input_height;
+
+  for (auto& metadata : request.input_buffer_metadata) {
+    block_request.input_buffer_metadata.push_back(
+        HalCameraMetadata::Clone(metadata.get()));
+  }
+
+  block_request.output_buffers = request.output_buffers;
+  for (auto& [camera_id, physical_metadata] : request.physical_camera_settings) {
+    block_request.physical_camera_settings[camera_id] =
+        HalCameraMetadata::Clone(physical_metadata.get());
+  }
+
+  std::vector<ProcessBlockRequest> block_requests(1);
+  block_requests[0].request = std::move(block_request);
+
+  return process_block_->ProcessRequests(block_requests, request);
+}
+
+status_t RealtimeZslResultRequestProcessor::Flush() {
+  ATRACE_CALL();
+  std::shared_lock lock(process_block_shared_lock_);
+  if (process_block_ == nullptr) {
+    return OK;
+  }
+
+  return process_block_->Flush();
+}
+
+void RealtimeZslResultRequestProcessor::Notify(
+    const ProcessBlockNotifyMessage& block_message) {
+  ATRACE_CALL();
+  std::lock_guard<std::mutex> lock(callback_lock_);
+  const NotifyMessage& message = block_message.message;
+  if (notify_ == nullptr) {
+    ALOGE("%s: notify_ is nullptr. Dropping a message.", __FUNCTION__);
+    return;
+  }
+
+  // Will return buffer for kErrorRequest and kErrorBuffer.
+  if (message.type == MessageType::kError) {
+    if (message.message.error.error_code == ErrorCode::kErrorRequest ||
+        message.message.error.error_code == ErrorCode::kErrorBuffer) {
+      pending_error_frames_.try_emplace(
+          message.message.error.frame_number,
+          RequestEntry{.capture_request = std::make_unique<CaptureRequest>()});
+    }
+  }
+  notify_(message);
+}
+
+}  // namespace google_camera_hal
+}  // namespace android
\ No newline at end of file
diff --git a/common/hal/google_camera_hal/realtime_zsl_result_request_processor.h b/common/hal/google_camera_hal/realtime_zsl_result_request_processor.h
new file mode 100644
index 0000000..609b2c3
--- /dev/null
+++ b/common/hal/google_camera_hal/realtime_zsl_result_request_processor.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_REQUEST_PROCESSOR_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_REQUEST_PROCESSOR_H_
+
+#include <cstdint>
+#include <shared_mutex>
+
+#include "hal_types.h"
+#include "internal_stream_manager.h"
+#include "realtime_zsl_result_processor.h"
+#include "request_processor.h"
+#include "result_processor.h"
+
+namespace android {
+namespace google_camera_hal {
+
+// RealtimeZslResultRequestProcessor implements a RealtimeZslResultProcessor
+// that return filled raw buffer and metadata to internal stream manager. It
+// also implements a RequestProcess to forward the results.
+class RealtimeZslResultRequestProcessor : public RealtimeZslResultProcessor,
+                                          RequestProcessor {
+ public:
+  static std::unique_ptr<RealtimeZslResultRequestProcessor> Create(
+      InternalStreamManager* internal_stream_manager, int32_t stream_id,
+      android_pixel_format_t pixel_format, uint32_t partial_result_count = 1);
+
+  virtual ~RealtimeZslResultRequestProcessor() = default;
+
+  // Override functions of RealtimeZslResultProcessor start.
+  void ProcessResult(ProcessBlockResult block_result) override;
+
+  void Notify(const ProcessBlockNotifyMessage& block_message) override;
+  // Override functions of RealtimeZslResultProcessor end.
+
+  // Override functions of RequestProcessor start.
+  status_t ConfigureStreams(
+      InternalStreamManager* internal_stream_manager,
+      const StreamConfiguration& stream_config,
+      StreamConfiguration* process_block_stream_config) override;
+
+  status_t SetProcessBlock(std::unique_ptr<ProcessBlock> process_block) override;
+
+  status_t ProcessRequest(const CaptureRequest& request) override;
+
+  status_t Flush() override;
+  // Override functions of RequestProcessor end.
+
+  void UpdateOutputBufferCount(int32_t frame_number, int output_buffer_count);
+
+ protected:
+  RealtimeZslResultRequestProcessor(
+      InternalStreamManager* internal_stream_manager, int32_t stream_id,
+      android_pixel_format_t pixel_format, uint32_t partial_result_count);
+
+ private:
+  std::shared_mutex process_block_shared_lock_;
+
+  // Protected by process_block_shared_lock_.
+  std::unique_ptr<ProcessBlock> process_block_;
+
+  // Simple wrapper struct to add partial result count to CaptureResult
+  struct RequestEntry {
+    std::unique_ptr<CaptureRequest> capture_request = nullptr;
+    uint32_t partial_results_received = 0;
+    bool zsl_buffer_received = false;
+    int framework_buffer_count = INT_MAX;
+  };
+
+  bool AllDataCollected(const RequestEntry& request_entry) const;
+
+  // Results collected so far on a valid frame. Results are passed to the
+  // processor block once all items in the RequestEntry struct are complete -
+  // i.e. all buffers arrived an all partial results arrived.
+  std::unordered_map<uint32_t, RequestEntry> pending_frame_number_to_requests_;
+  // Results collected so far on a frame with an error. Each result item gets
+  // reported to the upper layer as it comes in, and once the RequestEntry
+  // struct is complete the entry is removed.
+  std::unordered_map<uint32_t, RequestEntry> pending_error_frames_;
+};
+
+}  // namespace google_camera_hal
+}  // namespace android
+
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_ZSL_RESULT_REQUEST_PROCESSOR_H_
diff --git a/common/hal/google_camera_hal/rgbird_capture_session.cc b/common/hal/google_camera_hal/rgbird_capture_session.cc
index 5ec8e98..272b2a8 100644
--- a/common/hal/google_camera_hal/rgbird_capture_session.cc
+++ b/common/hal/google_camera_hal/rgbird_capture_session.cc
@@ -1093,9 +1093,10 @@ void RgbirdCaptureSession::NotifyHalMessage(const NotifyMessage& message) {
   }
 
   if (message.type == MessageType::kShutter) {
-    status_t res =
-        result_dispatcher_->AddShutter(message.message.shutter.frame_number,
-                                       message.message.shutter.timestamp_ns);
+    status_t res = result_dispatcher_->AddShutter(
+        message.message.shutter.frame_number,
+        message.message.shutter.timestamp_ns,
+        message.message.shutter.readout_timestamp_ns);
     if (res != OK) {
       ALOGE("%s: frame(%d) fail to AddShutter", __FUNCTION__,
             message.message.shutter.frame_number);
diff --git a/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc b/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc
index fa25403..151ed69 100644
--- a/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc
+++ b/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-//#define LOG_NDEBUG 0
+// #define LOG_NDEBUG 0
 
 #define LOG_TAG "GCH_ZslSnapshotCaptureSession"
 #define ATRACE_TAG ATRACE_TAG_CAMERA
@@ -27,6 +27,7 @@
 #include <utils/Trace.h>
 
 #include "hal_utils.h"
+#include "realtime_zsl_result_request_processor.h"
 #include "snapshot_request_processor.h"
 #include "snapshot_result_processor.h"
 #include "system/graphics-base-v1.0.h"
@@ -140,6 +141,57 @@ ZslSnapshotCaptureSession::CreateSnapshotProcessBlock() {
 #endif
 }
 
+std::unique_ptr<ProcessBlock>
+ZslSnapshotCaptureSession::CreateDenoiseProcessBlock() {
+  ATRACE_CALL();
+#if GCH_HWL_USE_DLOPEN
+  bool found_process_block = false;
+  for (const auto& lib_path :
+       utils::FindLibraryPaths(kExternalProcessBlockDir)) {
+    ALOGI("%s: Loading %s", __FUNCTION__, lib_path.c_str());
+    void* lib_handle = nullptr;
+    lib_handle = dlopen(lib_path.c_str(), RTLD_NOW);
+    if (lib_handle == nullptr) {
+      ALOGW("Failed loading %s.", lib_path.c_str());
+      continue;
+    }
+
+    GetProcessBlockFactoryFunc external_process_block_t =
+        reinterpret_cast<GetProcessBlockFactoryFunc>(
+            dlsym(lib_handle, "GetProcessBlockFactory"));
+    if (external_process_block_t == nullptr) {
+      ALOGE("%s: dlsym failed (%s) when loading %s.", __FUNCTION__,
+            "GetProcessBlockFactoryFunc", lib_path.c_str());
+      dlclose(lib_handle);
+      lib_handle = nullptr;
+      continue;
+    }
+
+    if (external_process_block_t()->GetBlockName() == "DenoiseProcessBlock") {
+      denoise_process_block_factory_ = external_process_block_t;
+      denoise_process_block_lib_handle_ = lib_handle;
+      found_process_block = true;
+      break;
+    }
+  }
+  if (!found_process_block) {
+    ALOGE("%s: denoise process block does not exist", __FUNCTION__);
+    return nullptr;
+  }
+
+  return denoise_process_block_factory_()->CreateProcessBlock(
+      camera_device_session_hwl_);
+#else
+  if (GetDenoiseProcessBlockFactory == nullptr) {
+    ALOGE("%s: denoise process block does not exist", __FUNCTION__);
+    return nullptr;
+  }
+  denoise_process_block_factory_ = GetDenoiseProcessBlockFactory;
+  return GetDenoiseProcessBlockFactory()->CreateProcessBlock(
+      camera_device_session_hwl_);
+#endif
+}
+
 bool ZslSnapshotCaptureSession::IsStreamConfigurationSupported(
     CameraDeviceSessionHwl* device_session_hwl,
     const StreamConfiguration& stream_config) {
@@ -242,6 +294,9 @@ ZslSnapshotCaptureSession::~ZslSnapshotCaptureSession() {
   // SnapshotRequestProcessor before the lib handle is released.
   release_thread.join();
   dlclose(snapshot_process_block_lib_handle_);
+  dlclose(denoise_process_block_lib_handle_);
+
+  ALOGI("%s: finished", __FUNCTION__);
 }
 
 status_t ZslSnapshotCaptureSession::BuildPipelines(
@@ -353,14 +408,27 @@ status_t ZslSnapshotCaptureSession::ConfigureStreams(
   }
 
   // Create preview result processor. Stream ID is not set at this stage.
-  auto realtime_result_processor = RealtimeZslResultProcessor::Create(
-      internal_stream_manager_.get(), additional_stream_id,
-      HAL_PIXEL_FORMAT_YCBCR_420_888, partial_result_count_);
+
+  std::unique_ptr<ResultProcessor> realtime_result_processor;
+  if (video_sw_denoise_enabled_) {
+    auto processor = RealtimeZslResultRequestProcessor::Create(
+        internal_stream_manager_.get(), additional_stream_id,
+        HAL_PIXEL_FORMAT_YCBCR_420_888, partial_result_count_);
+    realtime_zsl_result_request_processor_ = processor.get();
+    realtime_result_processor = std::move(processor);
+  } else {
+    realtime_result_processor = RealtimeZslResultProcessor::Create(
+        internal_stream_manager_.get(), additional_stream_id,
+        HAL_PIXEL_FORMAT_YCBCR_420_888, partial_result_count_);
+  }
+
   if (realtime_result_processor == nullptr) {
-    ALOGE("%s: Creating RealtimeZslResultProcessor failed.", __FUNCTION__);
+    ALOGE(
+        "%s: Creating "
+        "RealtimeZslResultProcessor/RealtimeZslResultRequestProcessor failed.",
+        __FUNCTION__);
     return UNKNOWN_ERROR;
   }
-  realtime_result_processor_ = realtime_result_processor.get();
   realtime_result_processor->SetResultCallback(process_capture_result, notify);
 
   res = process_block->SetResultProcessor(std::move(realtime_result_processor));
@@ -385,6 +453,56 @@ status_t ZslSnapshotCaptureSession::ConfigureStreams(
     }
   }
 
+  if (video_sw_denoise_enabled_) {
+    StreamConfiguration denoise_process_block_stream_config;
+    // Configure streams for request processor
+    res = realtime_zsl_result_request_processor_->ConfigureStreams(
+        internal_stream_manager_.get(), stream_config,
+        &denoise_process_block_stream_config);
+
+    if (res != OK) {
+      ALOGE(
+          "%s: Configuring stream for process block "
+          "(RealtimeZslResultRequestProcessor) failed.",
+          __FUNCTION__);
+      return res;
+    }
+
+    std::unique_ptr<ProcessBlock> denoise_processor =
+        CreateDenoiseProcessBlock();
+    // Create preview result processor. Stream ID is not set at this stage.
+    auto basic_result_processor = BasicResultProcessor::Create();
+    if (basic_result_processor == nullptr) {
+      ALOGE("%s: Creating BasicResultProcessor failed.", __FUNCTION__);
+      return UNKNOWN_ERROR;
+    }
+    basic_result_processor_ = basic_result_processor.get();
+    basic_result_processor->SetResultCallback(process_capture_result, notify);
+
+    res =
+        denoise_processor->SetResultProcessor(std::move(basic_result_processor));
+    if (res != OK) {
+      ALOGE("%s: Setting result process in process block failed.", __FUNCTION__);
+      return res;
+    }
+
+    // Configure streams for process block.
+    res = denoise_processor->ConfigureStreams(
+        denoise_process_block_stream_config, stream_config);
+    if (res != OK) {
+      ALOGE("%s: Configuring stream for process block failed.", __FUNCTION__);
+      return res;
+    }
+
+    res = realtime_zsl_result_request_processor_->SetProcessBlock(
+        std::move(denoise_processor));
+    if (res != OK) {
+      ALOGE("%s: Setting process block for RequestProcessor failed: %s(%d)",
+            __FUNCTION__, strerror(-res), res);
+      return res;
+    }
+  }
+
   return OK;
 }
 
@@ -487,13 +605,11 @@ status_t ZslSnapshotCaptureSession::SetupRealtimeProcessChain(
     ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) {
   ATRACE_CALL();
   if (realtime_process_block_ != nullptr ||
-      realtime_result_processor_ != nullptr ||
       realtime_request_processor_ != nullptr) {
     ALOGE(
-        "%s: realtime_process_block_(%p) or realtime_result_processor_(%p) or "
-        "realtime_request_processor_(%p) is/are "
-        "already set",
-        __FUNCTION__, realtime_process_block_, realtime_result_processor_,
+        "%s: realtime_process_block_(%p) or realtime_request_processor_(%p) "
+        "is/are already set",
+        __FUNCTION__, realtime_process_block_,
         realtime_request_processor_.get());
     return BAD_VALUE;
   }
@@ -596,6 +712,16 @@ status_t ZslSnapshotCaptureSession::Initialize(
     return BAD_VALUE;
   }
 
+  camera_metadata_ro_entry video_sw_denoise_entry;
+  res = characteristics->Get(VendorTagIds::kVideoSwDenoiseEnabled,
+                             &video_sw_denoise_entry);
+  if (res == OK && video_sw_denoise_entry.data.u8[0] == 1) {
+    video_sw_denoise_enabled_ = true;
+    ALOGI("%s: video sw denoise is enabled.", __FUNCTION__);
+  } else {
+    ALOGI("%s: video sw denoise is disabled.", __FUNCTION__);
+  }
+
   for (auto stream : stream_config.streams) {
     if (utils::IsPreviewStream(stream)) {
       hal_preview_stream_id_ = stream.id;
@@ -704,6 +830,11 @@ status_t ZslSnapshotCaptureSession::ProcessRequest(const CaptureRequest& request
       res = realtime_request_processor_->ProcessRequest(request);
     }
   } else {
+    if (realtime_zsl_result_request_processor_ != nullptr) {
+      realtime_zsl_result_request_processor_->UpdateOutputBufferCount(
+          request.frame_number, request.output_buffers.size());
+    }
+
     res = realtime_request_processor_->ProcessRequest(request);
   }
 
@@ -750,9 +881,10 @@ void ZslSnapshotCaptureSession::NotifyHalMessage(const NotifyMessage& message) {
   }
 
   if (message.type == MessageType::kShutter) {
-    status_t res =
-        result_dispatcher_->AddShutter(message.message.shutter.frame_number,
-                                       message.message.shutter.timestamp_ns);
+    status_t res = result_dispatcher_->AddShutter(
+        message.message.shutter.frame_number,
+        message.message.shutter.timestamp_ns,
+        message.message.shutter.readout_timestamp_ns);
     if (res != OK) {
       ALOGE("%s: AddShutter for frame %u failed: %s (%d).", __FUNCTION__,
             message.message.shutter.frame_number, strerror(-res), res);
diff --git a/common/hal/google_camera_hal/zsl_snapshot_capture_session.h b/common/hal/google_camera_hal/zsl_snapshot_capture_session.h
index 74b3cc3..a376030 100644
--- a/common/hal/google_camera_hal/zsl_snapshot_capture_session.h
+++ b/common/hal/google_camera_hal/zsl_snapshot_capture_session.h
@@ -17,6 +17,7 @@
 #ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_ZSL_SNAPSHOT_CAPTURE_SESSION_H_
 #define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_ZSL_SNAPSHOT_CAPTURE_SESSION_H_
 
+#include "basic_result_processor.h"
 #include "camera_buffer_allocator_hwl.h"
 #include "camera_device_session_hwl.h"
 #include "capture_session.h"
@@ -26,6 +27,7 @@
 #include "process_block.h"
 #include "realtime_zsl_request_processor.h"
 #include "realtime_zsl_result_processor.h"
+#include "realtime_zsl_result_request_processor.h"
 #include "request_processor.h"
 #include "result_processor.h"
 #include "snapshot_request_processor.h"
@@ -42,7 +44,7 @@ class CameraDeviceSession;
 //
 //  1.SnapshotRequestProcessor->SnapshotProcessBlock->SnapshotResultProcessor
 //
-//  2.RealtimeZslRequestProcessor->CaptureSessionWrapperProcessBlock->RealtimeZslResultProcessor
+//  2.RealtimeZslRequestProcessor->CaptureSessionWrapperProcessBlock->RealtimeZslResultRequestProcessor->DenoiseProcessBlock->BasicResultProcessor
 //                                    ||  /\
 //                                    \/  ||
 //                             embedded capture session
@@ -128,6 +130,7 @@ class ZslSnapshotCaptureSession : public CaptureSession {
       std::vector<HalStream>* hal_configured_streams);
 
   std::unique_ptr<ProcessBlock> CreateSnapshotProcessBlock();
+  std::unique_ptr<ProcessBlock> CreateDenoiseProcessBlock();
 
   // Invoked when receiving a result from result processor.
   void ProcessCaptureResult(std::unique_ptr<CaptureResult> result);
@@ -138,12 +141,11 @@ class ZslSnapshotCaptureSession : public CaptureSession {
   std::unique_ptr<InternalStreamManager> internal_stream_manager_;
 
   std::unique_ptr<RealtimeZslRequestProcessor> realtime_request_processor_;
+  RealtimeZslResultRequestProcessor* realtime_zsl_result_request_processor_ =
+      nullptr;
   // CaptureSessionWrapperProcessBlock will be owned and released by
   // RealtimeZslRequestProcessor.
   CaptureSessionWrapperProcessBlock* realtime_process_block_ = nullptr;
-  // RealtimeZslResultProcessor will be owned and released by
-  // CaptureSessionWrapperProcessBlock.
-  RealtimeZslResultProcessor* realtime_result_processor_ = nullptr;
 
   std::unique_ptr<SnapshotRequestProcessor> snapshot_request_processor_;
   // SnapshotProcessBlock will be owned and released by
@@ -152,6 +154,8 @@ class ZslSnapshotCaptureSession : public CaptureSession {
   // SnapshotResultProcessor will be owned and released by SnapshotProcessBlock.
   SnapshotResultProcessor* snapshot_result_processor_ = nullptr;
 
+  BasicResultProcessor* basic_result_processor_ = nullptr;
+
   // Use this stream id to check the request is ZSL compatible
   int32_t hal_preview_stream_id_ = -1;
 
@@ -181,8 +185,15 @@ class ZslSnapshotCaptureSession : public CaptureSession {
   // Opened library handles that should be closed on destruction
   void* snapshot_process_block_lib_handle_ = nullptr;
 
+  GetProcessBlockFactoryFunc denoise_process_block_factory_;
+  // Opened library handles that should be closed on destruction
+  void* denoise_process_block_lib_handle_ = nullptr;
+
   // Partial result count reported by HAL
   uint32_t partial_result_count_ = 1;
+
+  // Whether video software denoise is enabled
+  bool video_sw_denoise_enabled_ = false;
 };
 
 }  // namespace google_camera_hal
diff --git a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc b/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc
deleted file mode 100644
index ff619d8..0000000
--- a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google-lazy.rc
+++ /dev/null
@@ -1,13 +0,0 @@
-service vendor.camera-provider-2-7-google /vendor/bin/hw/android.hardware.camera.provider@2.7-service-google-lazy
-    interface android.hardware.camera.provider@2.4::ICameraProvider internal/0
-    interface android.hardware.camera.provider@2.5::ICameraProvider internal/0
-    interface android.hardware.camera.provider@2.6::ICameraProvider internal/0
-    interface android.hardware.camera.provider@2.7::ICameraProvider internal/0
-    oneshot
-    disabled
-    class hal
-    user system
-    group system
-    capabilities SYS_NICE
-    rlimit rtprio 10 10
-    task_profiles CameraServiceCapacity CameraServicePerformance
diff --git a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google.xml b/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google.xml
deleted file mode 100644
index 481b46e..0000000
--- a/common/hal/hidl_service/android.hardware.camera.provider@2.7-service-google.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<!-- Copyright (C) 2020 The Android Open Source Project
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<manifest version="1.0" type="device">
-    <hal format="hidl">
-        <name>android.hardware.camera.provider</name>
-        <transport>hwbinder</transport>
-        <version>2.7</version>
-        <interface>
-            <name>ICameraProvider</name>
-            <instance>internal/0</instance>
-        </interface>
-    </hal>
-</manifest>
diff --git a/common/hal/hidl_service/hidl_camera_device.cc b/common/hal/hidl_service/hidl_camera_device.cc
deleted file mode 100644
index fd45a5b..0000000
--- a/common/hal/hidl_service/hidl_camera_device.cc
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "GCH_HidlCameraDevice"
-//#define LOG_NDEBUG 0
-#include "hidl_camera_device.h"
-
-#include <log/log.h>
-
-#include "hidl_camera_device_session.h"
-#include "hidl_profiler.h"
-#include "hidl_utils.h"
-
-namespace android {
-namespace hardware {
-namespace camera {
-namespace device {
-namespace V3_7 {
-namespace implementation {
-
-namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
-
-using ::android::google_camera_hal::HalCameraMetadata;
-
-const std::string HidlCameraDevice::kDeviceVersion = "3.7";
-
-std::unique_ptr<HidlCameraDevice> HidlCameraDevice::Create(
-    std::unique_ptr<CameraDevice> google_camera_device) {
-  auto device = std::unique_ptr<HidlCameraDevice>(new HidlCameraDevice());
-  if (device == nullptr) {
-    ALOGE("%s: Cannot create a HidlCameraDevice.", __FUNCTION__);
-    return nullptr;
-  }
-
-  status_t res = device->Initialize(std::move(google_camera_device));
-  if (res != OK) {
-    ALOGE("%s: Initializing HidlCameraDevice failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    return nullptr;
-  }
-
-  return device;
-}
-
-status_t HidlCameraDevice::Initialize(
-    std::unique_ptr<CameraDevice> google_camera_device) {
-  if (google_camera_device == nullptr) {
-    ALOGE("%s: google_camera_device is nullptr.", __FUNCTION__);
-    return BAD_VALUE;
-  }
-
-  camera_id_ = google_camera_device->GetPublicCameraId();
-  google_camera_device_ = std::move(google_camera_device);
-  hidl_profiler_ = HidlProfiler::Create(camera_id_);
-  if (hidl_profiler_ == nullptr) {
-    ALOGE("%s: Failed to create HidlProfiler.", __FUNCTION__);
-    return UNKNOWN_ERROR;
-  }
-  hidl_profiler_->SetLatencyProfiler(google_camera_device_->GetProfiler(
-      camera_id_, hidl_profiler_->GetLatencyFlag()));
-  hidl_profiler_->SetFpsProfiler(google_camera_device_->GetProfiler(
-      camera_id_, hidl_profiler_->GetFpsFlag()));
-
-  return OK;
-}
-
-Return<void> HidlCameraDevice::getResourceCost(
-    ICameraDevice::getResourceCost_cb _hidl_cb) {
-  google_camera_hal::CameraResourceCost hal_cost;
-  CameraResourceCost hidl_cost;
-
-  status_t res = google_camera_device_->GetResourceCost(&hal_cost);
-  if (res != OK) {
-    ALOGE("%s: Getting resource cost failed for camera %u: %s(%d)",
-          __FUNCTION__, camera_id_, strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_cost);
-    return Void();
-  }
-
-  res = hidl_utils::ConvertToHidlResourceCost(hal_cost, &hidl_cost);
-  if (res != OK) {
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_cost);
-    return Void();
-  }
-
-  _hidl_cb(Status::OK, hidl_cost);
-  return Void();
-}
-
-Return<void> HidlCameraDevice::getCameraCharacteristics(
-    ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
-  V3_2::CameraMetadata hidl_characteristics;
-  std::unique_ptr<HalCameraMetadata> characteristics;
-  status_t res =
-      google_camera_device_->GetCameraCharacteristics(&characteristics);
-  if (res != OK) {
-    ALOGE("%s: Getting camera characteristics for camera %u failed: %s(%d)",
-          __FUNCTION__, camera_id_, strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_characteristics);
-    return Void();
-  }
-
-  if (characteristics == nullptr) {
-    ALOGE("%s: Camera characteristics for camera %u is nullptr.", __FUNCTION__,
-          camera_id_);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_characteristics);
-    return Void();
-  }
-
-  uint32_t metadata_size = characteristics->GetCameraMetadataSize();
-  hidl_characteristics.setToExternal(
-      (uint8_t*)characteristics->ReleaseCameraMetadata(), metadata_size,
-      /*shouldOwn*/ true);
-
-  _hidl_cb(Status::OK, hidl_characteristics);
-  return Void();
-}
-
-Return<Status> HidlCameraDevice::setTorchMode(TorchMode mode) {
-  google_camera_hal::TorchMode hal_torch_mode;
-  status_t res = hidl_utils::ConvertToHalTorchMode(mode, &hal_torch_mode);
-  if (res != OK) {
-    ALOGE("%s: failed to convert torch mode", __FUNCTION__);
-    return Status::INTERNAL_ERROR;
-  }
-
-  res = google_camera_device_->SetTorchMode(hal_torch_mode);
-  return hidl_utils::ConvertToHidlStatus(res);
-}
-
-Return<void> HidlCameraDevice::open(
-    const sp<V3_2::ICameraDeviceCallback>& callback,
-    ICameraDevice::open_cb _hidl_cb) {
-  auto profiler =
-      hidl_profiler_->MakeScopedProfiler(HidlProfiler::ScopedType::kOpen);
-
-  std::unique_ptr<google_camera_hal::CameraDeviceSession> session;
-  status_t res = google_camera_device_->CreateCameraDeviceSession(&session);
-  if (res != OK || session == nullptr) {
-    ALOGE("%s: Creating CameraDeviceSession failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), nullptr);
-    return Void();
-  }
-
-  auto hidl_session = HidlCameraDeviceSession::Create(
-      callback, std::move(session), hidl_profiler_);
-  if (hidl_session == nullptr) {
-    ALOGE("%s: Creating HidlCameraDeviceSession failed.", __FUNCTION__);
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), nullptr);
-    return Void();
-  }
-
-  _hidl_cb(Status::OK, hidl_session.release());
-  return Void();
-}
-
-Return<void> HidlCameraDevice::dumpState(
-    const ::android::hardware::hidl_handle& handle) {
-  if (handle.getNativeHandle() == nullptr) {
-    ALOGE("%s: handle is nullptr", __FUNCTION__);
-    return Void();
-  }
-
-  if (handle->numFds != 1 || handle->numInts != 0) {
-    ALOGE("%s: handle must contain 1 fd(%d) and 0 ints(%d)", __FUNCTION__,
-          handle->numFds, handle->numInts);
-    return Void();
-  }
-
-  int fd = handle->data[0];
-  google_camera_device_->DumpState(fd);
-  return Void();
-}
-
-Return<void> HidlCameraDevice::getPhysicalCameraCharacteristics(
-    const hidl_string& physicalCameraId,
-    ICameraDevice::getPhysicalCameraCharacteristics_cb _hidl_cb) {
-  V3_2::CameraMetadata hidl_characteristics;
-  std::unique_ptr<HalCameraMetadata> physical_characteristics;
-
-  uint32_t physical_camera_id = atoi(physicalCameraId.c_str());
-  status_t res = google_camera_device_->GetPhysicalCameraCharacteristics(
-      physical_camera_id, &physical_characteristics);
-  if (res != OK) {
-    ALOGE("%s: Getting physical characteristics for camera %u failed: %s(%d)",
-          __FUNCTION__, camera_id_, strerror(-res), res);
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_characteristics);
-    return Void();
-  }
-
-  if (physical_characteristics == nullptr) {
-    ALOGE("%s: Physical characteristics for camera %u is nullptr.",
-          __FUNCTION__, physical_camera_id);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_characteristics);
-    return Void();
-  }
-
-  uint32_t metadata_size = physical_characteristics->GetCameraMetadataSize();
-  hidl_characteristics.setToExternal(
-      (uint8_t*)physical_characteristics->ReleaseCameraMetadata(),
-      metadata_size, /*shouldOwn=*/true);
-
-  _hidl_cb(Status::OK, hidl_characteristics);
-  return Void();
-}
-
-Return<void> HidlCameraDevice::isStreamCombinationSupported(
-    const V3_4::StreamConfiguration& streams,
-    ICameraDevice::isStreamCombinationSupported_cb _hidl_cb) {
-  StreamConfiguration streams3_7;
-
-  hidl_utils::ConvertStreamConfigurationV34ToV37(streams, &streams3_7);
-
-  return isStreamCombinationSupported_3_7(streams3_7, _hidl_cb);
-}
-
-Return<void> HidlCameraDevice::isStreamCombinationSupported_3_7(
-    const V3_7::StreamConfiguration& streams,
-    ICameraDevice::isStreamCombinationSupported_cb _hidl_cb) {
-  bool is_supported = false;
-  google_camera_hal::StreamConfiguration stream_config;
-  status_t res = hidl_utils::ConverToHalStreamConfig(streams, &stream_config);
-  if (res != OK) {
-    ALOGE("%s: ConverToHalStreamConfig fail", __FUNCTION__);
-    _hidl_cb(Status::INTERNAL_ERROR, is_supported);
-    return Void();
-  }
-  is_supported =
-      google_camera_device_->IsStreamCombinationSupported(stream_config);
-
-  _hidl_cb(Status::OK, is_supported);
-  return Void();
-}
-
-}  // namespace implementation
-}  // namespace V3_7
-}  // namespace device
-}  // namespace camera
-}  // namespace hardware
-}  // namespace android
diff --git a/common/hal/hidl_service/hidl_camera_device.h b/common/hal/hidl_service/hidl_camera_device.h
deleted file mode 100644
index 824d64d..0000000
--- a/common/hal/hidl_service/hidl_camera_device.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_H_
-#define HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_H_
-
-#include <android/hardware/camera/device/3.5/ICameraDeviceCallback.h>
-#include <android/hardware/camera/device/3.7/ICameraDevice.h>
-
-#include "camera_device.h"
-#include "hidl_profiler.h"
-
-namespace android {
-namespace hardware {
-namespace camera {
-namespace device {
-namespace V3_7 {
-namespace implementation {
-
-using ::android::hardware::camera::common::V1_0::CameraResourceCost;
-using ::android::hardware::camera::common::V1_0::Status;
-using ::android::hardware::camera::common::V1_0::TorchMode;
-using ::android::hardware::camera::device::V3_5::ICameraDeviceCallback;
-using ::android::hardware::camera::device::V3_7::ICameraDevice;
-using ::android::hardware::camera::implementation::HidlProfiler;
-
-using ::android::google_camera_hal::CameraDevice;
-
-// HidlCameraDevice implements the HIDL camera device interface, ICameraDevice,
-// using Google Camera HAL to provide information about the associated camera
-// device.
-class HidlCameraDevice : public ICameraDevice {
- public:
-  static const std::string kDeviceVersion;
-
-  // Create a HidlCameraDevice.
-  // google_camera_device is a google camera device that HidlCameraDevice
-  // is going to manage. Creating a HidlCameraDevice will fail if
-  // google_camera_device is nullptr.
-  static std::unique_ptr<HidlCameraDevice> Create(
-      std::unique_ptr<CameraDevice> google_camera_device);
-  virtual ~HidlCameraDevice() = default;
-
-  // Override functions in ICameraDevice
-  Return<void> getResourceCost(
-      ICameraDevice::getResourceCost_cb _hidl_cb) override;
-
-  Return<void> getCameraCharacteristics(
-      ICameraDevice::getCameraCharacteristics_cb _hidl_cb) override;
-
-  Return<Status> setTorchMode(TorchMode mode) override;
-
-  Return<void> open(const sp<V3_2::ICameraDeviceCallback>& callback,
-                    ICameraDevice::open_cb _hidl_cb) override;
-
-  Return<void> dumpState(const ::android::hardware::hidl_handle& handle) override;
-
-  Return<void> getPhysicalCameraCharacteristics(
-      const hidl_string& physicalCameraId,
-      ICameraDevice::getPhysicalCameraCharacteristics_cb _hidl_cb) override;
-
-  Return<void> isStreamCombinationSupported(
-      const V3_4::StreamConfiguration& streams,
-      ICameraDevice::isStreamCombinationSupported_cb _hidl_cb) override;
-
-  Return<void> isStreamCombinationSupported_3_7(
-      const StreamConfiguration& streams,
-      ICameraDevice::isStreamCombinationSupported_cb _hidl_cb) override;
-
-  // End of override functions in ICameraDevice
-
- protected:
-  HidlCameraDevice() = default;
-
- private:
-  status_t Initialize(std::unique_ptr<CameraDevice> google_camera_device);
-
-  std::unique_ptr<CameraDevice> google_camera_device_;
-  uint32_t camera_id_ = 0;
-  std::shared_ptr<HidlProfiler> hidl_profiler_;
-};
-
-}  // namespace implementation
-}  // namespace V3_7
-}  // namespace device
-}  // namespace camera
-}  // namespace hardware
-}  // namespace android
-
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_DEVICE_H_
diff --git a/common/hal/hidl_service/hidl_camera_provider.cc b/common/hal/hidl_service/hidl_camera_provider.cc
deleted file mode 100644
index 528d23d..0000000
--- a/common/hal/hidl_service/hidl_camera_provider.cc
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "GCH_HidlCameraProvider"
-//#define LOG_NDEBUG 0
-#include <log/log.h>
-#include <regex>
-
-#include "camera_device.h"
-#include "hidl_camera_device.h"
-#include "hidl_camera_provider.h"
-#include "hidl_utils.h"
-
-namespace android {
-namespace hardware {
-namespace camera {
-namespace provider {
-namespace V2_7 {
-namespace implementation {
-
-namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
-
-using ::android::google_camera_hal::CameraDevice;
-using ::android::hardware::Void;
-using ::android::hardware::camera::common::V1_0::CameraDeviceStatus;
-using ::android::hardware::camera::common::V1_0::TorchModeStatus;
-using ::android::hardware::camera::common::V1_0::VendorTagSection;
-
-const std::string HidlCameraProvider::kProviderName = "internal";
-// "device@<version>/internal/<id>"
-const std::regex HidlCameraProvider::kDeviceNameRegex(
-    "device@([0-9]+\\.[0-9]+)/internal/(.+)");
-
-android::sp<HidlCameraProvider> HidlCameraProvider::Create() {
-  android::sp<HidlCameraProvider> provider = new HidlCameraProvider();
-
-  status_t res = provider->Initialize();
-  if (res != OK) {
-    ALOGE("%s: Initializing HidlCameraProvider failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    return nullptr;
-  }
-
-  return provider;
-}
-
-status_t HidlCameraProvider::Initialize() {
-  google_camera_provider_ = CameraProvider::Create();
-  if (google_camera_provider_ == nullptr) {
-    ALOGE("%s: Creating CameraProvider failed.", __FUNCTION__);
-    return NO_INIT;
-  }
-
-  camera_provider_callback_ = {
-      .camera_device_status_change = google_camera_hal::CameraDeviceStatusChangeFunc(
-          [this](std::string camera_id,
-                 google_camera_hal::CameraDeviceStatus new_status) {
-            if (callbacks_ == nullptr) {
-              ALOGE("%s: callbacks_ is null", __FUNCTION__);
-              return;
-            }
-            CameraDeviceStatus hidl_camera_device_status;
-            status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
-                new_status, &hidl_camera_device_status);
-            if (res != OK) {
-              ALOGE(
-                  "%s: Converting to hidl camera device status failed: %s(%d)",
-                  __FUNCTION__, strerror(-res), res);
-              return;
-            }
-
-            std::unique_lock<std::mutex> lock(callbacks_lock_);
-            auto cb_status = callbacks_->cameraDeviceStatusChange(
-                "device@" +
-                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
-                    "/" + kProviderName + "/" + camera_id,
-                hidl_camera_device_status);
-            if (!cb_status.isOk()) {
-              ALOGE("%s: device status change transaction error: %s",
-                    __FUNCTION__, cb_status.description().c_str());
-              return;
-            }
-          }),
-      .physical_camera_device_status_change = google_camera_hal::
-          PhysicalCameraDeviceStatusChangeFunc([this](
-                                                   std::string camera_id,
-                                                   std::string physical_camera_id,
-                                                   google_camera_hal::CameraDeviceStatus
-                                                       new_status) {
-            if (callbacks_ == nullptr) {
-              ALOGE("%s: callbacks_ is null", __FUNCTION__);
-              return;
-            }
-            auto castResult =
-                provider::V2_6::ICameraProviderCallback::castFrom(callbacks_);
-            if (!castResult.isOk()) {
-              ALOGE("%s: callbacks_ cannot be casted to version 2.6",
-                    __FUNCTION__);
-              return;
-            }
-            sp<provider::V2_6::ICameraProviderCallback> callbacks_2_6_ =
-                castResult;
-            if (callbacks_2_6_ == nullptr) {
-              ALOGE("%s: callbacks_2_6_ is null", __FUNCTION__);
-              return;
-            }
-
-            CameraDeviceStatus hidl_camera_device_status;
-            status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
-                new_status, &hidl_camera_device_status);
-            if (res != OK) {
-              ALOGE(
-                  "%s: Converting to hidl camera device status failed: %s(%d)",
-                  __FUNCTION__, strerror(-res), res);
-              return;
-            }
-
-            std::unique_lock<std::mutex> lock(callbacks_lock_);
-            callbacks_2_6_->physicalCameraDeviceStatusChange(
-                "device@" +
-                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
-                    "/" + kProviderName + "/" + camera_id,
-                physical_camera_id, hidl_camera_device_status);
-          }),
-      .torch_mode_status_change = google_camera_hal::TorchModeStatusChangeFunc(
-          [this](std::string camera_id,
-                 google_camera_hal::TorchModeStatus new_status) {
-            if (callbacks_ == nullptr) {
-              ALOGE("%s: callbacks_ is null", __FUNCTION__);
-              return;
-            }
-
-            TorchModeStatus hidl_torch_status;
-            status_t res = hidl_utils::ConvertToHidlTorchModeStatus(
-                new_status, &hidl_torch_status);
-            if (res != OK) {
-              ALOGE("%s: Converting to hidl torch status failed: %s(%d)",
-                    __FUNCTION__, strerror(-res), res);
-              return;
-            }
-
-            std::unique_lock<std::mutex> lock(callbacks_lock_);
-            auto cb_status = callbacks_->torchModeStatusChange(
-                "device@" +
-                    device::V3_7::implementation::HidlCameraDevice::kDeviceVersion +
-                    "/" + kProviderName + "/" + camera_id,
-                hidl_torch_status);
-            if (!cb_status.isOk()) {
-              ALOGE("%s: torch status change transaction error: %s",
-                    __FUNCTION__, cb_status.description().c_str());
-              return;
-            }
-          }),
-  };
-
-  google_camera_provider_->SetCallback(&camera_provider_callback_);
-  // purge pending malloc pages after initialization
-  mallopt(M_PURGE, 0);
-  return OK;
-}
-
-Return<Status> HidlCameraProvider::setCallback(
-    const sp<ICameraProviderCallback>& callback) {
-  bool first_time = false;
-  {
-    std::unique_lock<std::mutex> lock(callbacks_lock_);
-    first_time = callbacks_ == nullptr;
-    callbacks_ = callback;
-  }
-  google_camera_provider_->TriggerDeferredCallbacks();
-#ifdef __ANDROID_APEX__
-  if (first_time) {
-    std::string ready_property_name = "vendor.camera.hal.ready.count";
-    int ready_count = property_get_int32(ready_property_name.c_str(), 0);
-    property_set(ready_property_name.c_str(),
-                 std::to_string(++ready_count).c_str());
-    ALOGI("HidlCameraProvider::setCallback() first time ready count: %d ",
-          ready_count);
-  }
-#endif
-  return Status::OK;
-}
-
-Return<void> HidlCameraProvider::getVendorTags(getVendorTags_cb _hidl_cb) {
-  hidl_vec<VendorTagSection> hidl_vendor_tag_sections;
-  std::vector<google_camera_hal::VendorTagSection> hal_vendor_tag_sections;
-
-  status_t res =
-      google_camera_provider_->GetVendorTags(&hal_vendor_tag_sections);
-  if (res != OK) {
-    ALOGE("%s: Getting vendor tags failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
-    return Void();
-  }
-
-  res = hidl_utils::ConvertToHidlVendorTagSections(hal_vendor_tag_sections,
-                                                   &hidl_vendor_tag_sections);
-  if (res != OK) {
-    ALOGE("%s: Converting to hidl vendor tags failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
-    return Void();
-  }
-
-  _hidl_cb(Status::OK, hidl_vendor_tag_sections);
-  return Void();
-}
-
-Return<void> HidlCameraProvider::getCameraIdList(getCameraIdList_cb _hidl_cb) {
-  std::vector<uint32_t> camera_ids;
-  hidl_vec<hidl_string> hidl_camera_ids;
-  status_t res = google_camera_provider_->GetCameraIdList(&camera_ids);
-  if (res != OK) {
-    ALOGE("%s: Getting camera ID list failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_ids);
-    return Void();
-  }
-
-  hidl_camera_ids.resize(camera_ids.size());
-  for (uint32_t i = 0; i < hidl_camera_ids.size(); i++) {
-    // camera ID is in the form of "device@<major>.<minor>/<type>/<id>"
-    hidl_camera_ids[i] =
-        "device@" +
-        device::V3_7::implementation::HidlCameraDevice::kDeviceVersion + "/" +
-        kProviderName + "/" + std::to_string(camera_ids[i]);
-  }
-
-  _hidl_cb(Status::OK, hidl_camera_ids);
-  return Void();
-}
-
-Return<void> HidlCameraProvider::getConcurrentStreamingCameraIds(
-    getConcurrentStreamingCameraIds_cb _hidl_cb) {
-  hidl_vec<hidl_vec<hidl_string>> hidl_camera_id_combinations;
-  std::vector<std::unordered_set<uint32_t>> camera_id_combinations;
-  status_t res = google_camera_provider_->GetConcurrentStreamingCameraIds(
-      &camera_id_combinations);
-  if (res != OK) {
-    ALOGE(
-        "%s: Getting the combinations of concurrent streaming camera ids "
-        "failed: %s(%d)",
-        __FUNCTION__, strerror(-res), res);
-    _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_id_combinations);
-    return Void();
-  }
-  hidl_camera_id_combinations.resize(camera_id_combinations.size());
-  int i = 0;
-  for (auto& combination : camera_id_combinations) {
-    hidl_vec<hidl_string> hidl_combination(combination.size());
-    int c = 0;
-    for (auto& camera_id : combination) {
-      hidl_combination[c] = std::to_string(camera_id);
-      c++;
-    }
-    hidl_camera_id_combinations[i] = hidl_combination;
-    i++;
-  }
-  _hidl_cb(Status::OK, hidl_camera_id_combinations);
-  return Void();
-}
-
-Return<void> HidlCameraProvider::isConcurrentStreamCombinationSupported(
-    const hidl_vec<provider::V2_6::CameraIdAndStreamCombination>& configs,
-    isConcurrentStreamCombinationSupported_cb _hidl_cb) {
-  hidl_vec<CameraIdAndStreamCombination> configs2_7;
-  configs2_7.resize(configs.size());
-  for (size_t i = 0; i < configs.size(); i++) {
-    configs2_7[i].cameraId = configs[i].cameraId;
-
-    hidl_utils::ConvertStreamConfigurationV34ToV37(
-        configs[i].streamConfiguration, &configs2_7[i].streamConfiguration);
-  }
-
-  return isConcurrentStreamCombinationSupported_2_7(configs2_7, _hidl_cb);
-}
-
-Return<void> HidlCameraProvider::isConcurrentStreamCombinationSupported_2_7(
-    const hidl_vec<CameraIdAndStreamCombination>& configs,
-    isConcurrentStreamCombinationSupported_cb _hidl_cb) {
-  std::vector<google_camera_hal::CameraIdAndStreamConfiguration>
-      devices_stream_configs(configs.size());
-  status_t res = OK;
-  size_t c = 0;
-  for (auto& config : configs) {
-    res = hidl_utils::ConverToHalStreamConfig(
-        config.streamConfiguration,
-        &devices_stream_configs[c].stream_configuration);
-    if (res != OK) {
-      ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
-      _hidl_cb(Status::INTERNAL_ERROR, false);
-      return Void();
-    }
-    uint32_t camera_id = atoi(config.cameraId.c_str());
-    devices_stream_configs[c].camera_id = camera_id;
-    c++;
-  }
-  bool is_supported = false;
-  res = google_camera_provider_->IsConcurrentStreamCombinationSupported(
-      devices_stream_configs, &is_supported);
-  if (res != OK) {
-    ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
-    _hidl_cb(Status::INTERNAL_ERROR, false);
-    return Void();
-  }
-  _hidl_cb(Status::OK, is_supported);
-  return Void();
-}
-
-Return<void> HidlCameraProvider::isSetTorchModeSupported(
-    isSetTorchModeSupported_cb _hidl_cb) {
-  bool is_supported = google_camera_provider_->IsSetTorchModeSupported();
-  _hidl_cb(Status::OK, is_supported);
-  return Void();
-}
-
-Return<void> HidlCameraProvider::getCameraDeviceInterface_V1_x(
-    const hidl_string& /*cameraDeviceName*/,
-    getCameraDeviceInterface_V1_x_cb _hidl_cb) {
-  _hidl_cb(Status::OPERATION_NOT_SUPPORTED, nullptr);
-  return Void();
-}
-
-bool HidlCameraProvider::ParseDeviceName(const hidl_string& device_name,
-                                         std::string* device_version,
-                                         std::string* camera_id) {
-  std::string device_name_std(device_name.c_str());
-  std::smatch sm;
-
-  if (std::regex_match(device_name_std, sm,
-                       HidlCameraProvider::kDeviceNameRegex)) {
-    if (device_version != nullptr) {
-      *device_version = sm[1];
-    }
-    if (camera_id != nullptr) {
-      *camera_id = sm[2];
-    }
-    return true;
-  }
-  return false;
-}
-
-Return<void> HidlCameraProvider::getCameraDeviceInterface_V3_x(
-    const hidl_string& camera_device_name,
-    getCameraDeviceInterface_V3_x_cb _hidl_cb) {
-  std::unique_ptr<CameraDevice> google_camera_device;
-
-  // Parse camera_device_name.
-  std::string camera_id, device_version;
-
-  bool match = ParseDeviceName(camera_device_name, &device_version, &camera_id);
-  if (!match) {
-    ALOGE("%s: Device name parse fail. ", __FUNCTION__);
-    _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
-    return Void();
-  }
-
-  status_t res = google_camera_provider_->CreateCameraDevice(
-      atoi(camera_id.c_str()), &google_camera_device);
-  if (res != OK) {
-    ALOGE("%s: Creating CameraDevice failed: %s(%d)", __FUNCTION__,
-          strerror(-res), res);
-    _hidl_cb(hidl_utils::ConvertToHidlStatus(res), nullptr);
-    return Void();
-  }
-
-  auto hidl_camera_device =
-      device::V3_7::implementation::HidlCameraDevice::Create(
-          std::move(google_camera_device));
-  if (hidl_camera_device == nullptr) {
-    ALOGE("%s: Creating HidlCameraDevice failed", __FUNCTION__);
-    _hidl_cb(Status::INTERNAL_ERROR, nullptr);
-    return Void();
-  }
-
-  _hidl_cb(Status::OK, hidl_camera_device.release());
-  return Void();
-}
-
-Return<void> HidlCameraProvider::notifyDeviceStateChange(
-    hardware::hidl_bitfield<DeviceState> new_state) {
-  google_camera_hal::DeviceState device_state =
-      google_camera_hal::DeviceState::kNormal;
-  ::android::hardware::camera::implementation::hidl_utils::ConvertToHalDeviceState(
-      new_state, device_state);
-  google_camera_provider_->NotifyDeviceStateChange(device_state);
-  return Void();
-}
-
-}  // namespace implementation
-}  // namespace V2_7
-}  // namespace provider
-}  // namespace camera
-}  // namespace hardware
-}  // namespace android
diff --git a/common/hal/hidl_service/hidl_camera_provider.h b/common/hal/hidl_service/hidl_camera_provider.h
deleted file mode 100644
index 31efc14..0000000
--- a/common/hal/hidl_service/hidl_camera_provider.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_PROVIDER_H_
-#define HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_PROVIDER_H_
-
-#include <android/hardware/camera/provider/2.6/ICameraProviderCallback.h>
-#include <android/hardware/camera/provider/2.7/ICameraProvider.h>
-#include <regex>
-#include "camera_provider.h"
-
-namespace android {
-namespace hardware {
-namespace camera {
-namespace provider {
-namespace V2_7 {
-namespace implementation {
-
-using ::android::sp;
-using ::android::hardware::hidl_string;
-using ::android::hardware::hidl_vec;
-using ::android::hardware::Return;
-using ::android::hardware::camera::common::V1_0::Status;
-using ::android::hardware::camera::provider::V2_4::ICameraProviderCallback;
-using ::android::hardware::camera::provider::V2_5::DeviceState;
-using ::android::hardware::camera::provider::V2_7::CameraIdAndStreamCombination;
-using ::android::hardware::camera::provider::V2_7::ICameraProvider;
-
-using ::android::google_camera_hal::CameraProvider;
-
-// HidlCameraProvider implements the HIDL camera provider interface,
-// ICameraProvider, to enumerate the available individual camera devices
-// in the system, and provide updates about changes to device status.
-class HidlCameraProvider : public ICameraProvider {
- public:
-  static const std::string kProviderName;
-  static android::sp<HidlCameraProvider> Create();
-  virtual ~HidlCameraProvider() = default;
-
-  // Override functions in ICameraProvider.
-  Return<Status> setCallback(
-      const sp<ICameraProviderCallback>& callback) override;
-
-  Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override;
-
-  Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override;
-
-  Return<void> isSetTorchModeSupported(
-      isSetTorchModeSupported_cb _hidl_cb) override;
-
-  Return<void> getConcurrentStreamingCameraIds(
-      getConcurrentStreamingCameraIds_cb _hidl_cb) override;
-
-  Return<void> isConcurrentStreamCombinationSupported(
-      const hidl_vec<V2_6::CameraIdAndStreamCombination>& configs,
-      isConcurrentStreamCombinationSupported_cb _hidl_cb) override;
-
-  Return<void> isConcurrentStreamCombinationSupported_2_7(
-      const hidl_vec<CameraIdAndStreamCombination>& configs,
-      isConcurrentStreamCombinationSupported_cb _hidl_cb) override;
-
-  Return<void> getCameraDeviceInterface_V1_x(
-      const hidl_string& cameraDeviceName,
-      getCameraDeviceInterface_V1_x_cb _hidl_cb) override;
-
-  Return<void> getCameraDeviceInterface_V3_x(
-      const hidl_string& cameraDeviceName,
-      getCameraDeviceInterface_V3_x_cb _hidl_cb) override;
-
-  Return<void> notifyDeviceStateChange(
-      hardware::hidl_bitfield<DeviceState> newState) override;
-  // End of override functions in ICameraProvider.
-
- protected:
-  HidlCameraProvider() = default;
-
- private:
-  static const std::regex kDeviceNameRegex;
-
-  status_t Initialize();
-
-  // Parse device version and camera ID.
-  bool ParseDeviceName(const hidl_string& device_name,
-                       std::string* device_version, std::string* camera_id);
-
-  std::mutex callbacks_lock_;
-  sp<ICameraProviderCallback> callbacks_;
-
-  std::unique_ptr<CameraProvider> google_camera_provider_;
-  google_camera_hal::CameraProviderCallback camera_provider_callback_;
-};
-
-}  // namespace implementation
-}  // namespace V2_7
-}  // namespace provider
-}  // namespace camera
-}  // namespace hardware
-}  // namespace android
-
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_CAMERA_PROVIDER_H_
diff --git a/common/hal/hidl_service/hidl_utils.h b/common/hal/hidl_service/hidl_utils.h
deleted file mode 100644
index c8003e7..0000000
--- a/common/hal/hidl_service/hidl_utils.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_UTILS_H_
-#define HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_UTILS_H_
-
-#include <android/hardware/camera/common/1.0/types.h>
-#include <android/hardware/camera/device/3.7/ICameraDeviceSession.h>
-#include <fmq/MessageQueue.h>
-#include <hal_types.h>
-#include <hidl/HidlSupport.h>
-#include <memory>
-#include "hidl_camera_provider.h"
-
-namespace android {
-namespace hardware {
-namespace camera {
-namespace implementation {
-namespace hidl_utils {
-
-using ::android::hardware::hidl_vec;
-using ::android::hardware::camera::common::V1_0::CameraDeviceStatus;
-using ::android::hardware::camera::common::V1_0::CameraMetadataType;
-using ::android::hardware::camera::common::V1_0::CameraResourceCost;
-using ::android::hardware::camera::common::V1_0::Status;
-using ::android::hardware::camera::common::V1_0::TorchMode;
-using ::android::hardware::camera::common::V1_0::TorchModeStatus;
-using ::android::hardware::camera::common::V1_0::VendorTagSection;
-using ::android::hardware::camera::device::V3_2::BufferCache;
-using ::android::hardware::camera::device::V3_2::BufferStatus;
-using ::android::hardware::camera::device::V3_2::CameraMetadata;
-using ::android::hardware::camera::device::V3_2::NotifyMsg;
-using ::android::hardware::camera::device::V3_2::RequestTemplate;
-using ::android::hardware::camera::device::V3_2::StreamBuffer;
-using ::android::hardware::camera::device::V3_2::StreamConfigurationMode;
-using ::android::hardware::camera::device::V3_2::StreamRotation;
-using ::android::hardware::camera::device::V3_2::StreamType;
-using ::android::hardware::camera::device::V3_4::CaptureResult;
-using ::android::hardware::camera::device::V3_4::Stream;
-using ::android::hardware::camera::device::V3_5::BufferRequest;
-using ::android::hardware::camera::device::V3_5::BufferRequestStatus;
-using ::android::hardware::camera::device::V3_5::StreamBufferRequestError;
-using ::android::hardware::camera::device::V3_5::StreamBufferRet;
-using ::android::hardware::camera::device::V3_5::StreamBuffersVal;
-using ::android::hardware::camera::device::V3_6::HalStreamConfiguration;
-using ::android::hardware::camera::device::V3_7::CaptureRequest;
-using ::android::hardware::camera::device::V3_7::StreamConfiguration;
-using ::android::hardware::camera::provider::V2_5::DeviceState;
-
-// Util functions to convert the types between HIDL and Google Camera HAL.
-
-// Conversions from HAL to HIDL
-status_t ConvertToHidlVendorTagSections(
-    const std::vector<google_camera_hal::VendorTagSection>& hal_sections,
-    hidl_vec<VendorTagSection>* hidl_sections);
-
-status_t ConvertToHidlVendorTagType(
-    google_camera_hal::CameraMetadataType hal_type,
-    CameraMetadataType* hidl_type);
-
-status_t ConvertToHidlResourceCost(
-    const google_camera_hal::CameraResourceCost& hal_cost,
-    CameraResourceCost* hidl_cost);
-
-status_t ConvertToHidlHalStreamConfig(
-    const std::vector<google_camera_hal::HalStream>& hal_configured_streams,
-    HalStreamConfiguration* hidl_hal_stream_config);
-
-// Convert a HAL result to a HIDL result. It will try to write the result
-// metadata to result_metadata_queue. If it fails, it will write the result
-// metadata in hidl_result.
-status_t ConvertToHidlCaptureResult(
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
-    std::unique_ptr<google_camera_hal::CaptureResult> hal_result,
-    CaptureResult* hidl_result);
-
-status_t ConverToHidlNotifyMessage(
-    const google_camera_hal::NotifyMessage& hal_message,
-    NotifyMsg* hidl_message);
-
-// Convert from HAL status_t to HIDL Status
-// OK is converted to Status::OK.
-// BAD_VALUE is converted to Status::ILLEGAL_ARGUMENT.
-// -EBUSY is converted to Status::CAMERA_IN_USE.
-// -EUSERS is converted to Status::MAX_CAMERAS_IN_USE.
-// UNKNOWN_TRANSACTION is converted to Status::METHOD_NOT_SUPPORTED.
-// INVALID_OPERATION is converted to Status::OPERATION_NOT_SUPPORTED.
-// DEAD_OBJECT is converted to Status::CAMERA_DISCONNECTED.
-// All other errors are converted to Status::INTERNAL_ERROR.
-Status ConvertToHidlStatus(status_t hal_status);
-
-// Convert from HAL CameraDeviceStatus to HIDL CameraDeviceStatus
-// kNotPresent is converted to CameraDeviceStatus::NOT_PRESENT.
-// kPresent is converted to CameraDeviceStatus::PRESENT.
-// kEnumerating is converted to CameraDeviceStatus::ENUMERATING.
-status_t ConvertToHidlCameraDeviceStatus(
-    google_camera_hal::CameraDeviceStatus hal_camera_device_status,
-    CameraDeviceStatus* hidl_camera_device_status);
-
-// Convert from HAL TorchModeStatus to HIDL TorchModeStatus
-// kNotAvailable is converted to TorchModeStatus::NOT_AVAILABLE.
-// kAvailableOff is converted to TorchModeStatus::AVAILABLE_OFF.
-// kAvailableOn is converted to TorchModeStatus::AVAILABLE_ON.
-status_t ConvertToHidlTorchModeStatus(
-    google_camera_hal::TorchModeStatus hal_torch_status,
-    TorchModeStatus* hidl_torch_status);
-
-// Convert a HAL request to a HIDL request.
-status_t ConvertToHidlBufferRequest(
-    const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
-    hidl_vec<BufferRequest>* hidl_buffer_requests);
-
-// Convert a HAL stream buffer to a HIDL hidl stream buffer.
-status_t ConvertToHidlStreamBuffer(
-    const google_camera_hal::StreamBuffer& hal_buffer,
-    StreamBuffer* hidl_buffer);
-
-// Conversions from HIDL to HAL.
-status_t ConvertToHalTemplateType(
-    RequestTemplate hidl_template,
-    google_camera_hal::RequestTemplate* hal_template);
-
-status_t ConvertToHalStreamBuffer(const StreamBuffer& hidl_buffer,
-                                  google_camera_hal::StreamBuffer* hal_buffer);
-
-status_t ConvertToHalMetadata(
-    uint32_t message_queue_setting_size,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
-    const CameraMetadata& request_settings,
-    std::unique_ptr<google_camera_hal::HalCameraMetadata>* hal_metadata);
-
-status_t ConvertToHalCaptureRequest(
-    const CaptureRequest& hidl_request,
-    MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
-    google_camera_hal::CaptureRequest* hal_request);
-
-status_t ConvertToHalBufferCaches(
-    const hidl_vec<BufferCache>& hidl_buffer_caches,
-    std::vector<google_camera_hal::BufferCache>* hal_buffer_caches);
-
-status_t ConverToHalStreamConfig(
-    const StreamConfiguration& hidl_stream_config,
-    google_camera_hal::StreamConfiguration* hal_stream_config);
-
-status_t ConverToHalStreamConfig(
-    const device::V3_4::StreamConfiguration& hidl_stream_config,
-    google_camera_hal::StreamConfiguration* hal_stream_config);
-
-status_t ConvertToHalStreamConfigurationMode(
-    StreamConfigurationMode hidl_mode,
-    google_camera_hal::StreamConfigurationMode* hal_mode);
-
-status_t ConvertToHalBufferStatus(BufferStatus hidl_status,
-                                  google_camera_hal::BufferStatus* hal_status);
-
-status_t ConvertToHalStream(const Stream& hidl_stream,
-                            google_camera_hal::Stream* hal_stream);
-
-status_t ConvertToHalStreamRotation(
-    StreamRotation hidl_stream_rotation,
-    google_camera_hal::StreamRotation* hal_stream_rotation);
-
-status_t ConvertToHalStreamType(StreamType hidl_stream_type,
-                                google_camera_hal::StreamType* hal_stream_type);
-
-status_t ConvertToHalTorchMode(TorchMode hidl_torch_mode,
-                               google_camera_hal::TorchMode* hal_torch_mode);
-
-status_t ConvertToHalBufferRequestStatus(
-    const BufferRequestStatus& hidl_buffer_request_status,
-    google_camera_hal::BufferRequestStatus* hal_buffer_request_status);
-
-status_t ConvertToHalBufferReturnStatus(
-    const StreamBufferRet& hidl_stream_buffer_return,
-    google_camera_hal::BufferReturn* hal_buffer_return);
-
-status_t ConvertStreamConfigurationV34ToV37(
-    const device::V3_4::StreamConfiguration& config_3_4,
-    StreamConfiguration* config_3_7);
-
-status_t ConvertToHalDeviceState(
-    const hardware::hidl_bitfield<DeviceState> hidl_device_state,
-    google_camera_hal::DeviceState& hal_device_state);
-
-}  // namespace hidl_utils
-}  // namespace implementation
-}  // namespace camera
-}  // namespace hardware
-}  // namespace android
-
-#endif  // HARDWARE_GOOGLE_CAMERA_HAL_HIDL_SERVICE_HIDL_UTILS_H_
diff --git a/common/hal/hwl_interface/camera_device_hwl.h b/common/hal/hwl_interface/camera_device_hwl.h
index 19cd5fa..8bd8ead 100644
--- a/common/hal/hwl_interface/camera_device_hwl.h
+++ b/common/hal/hwl_interface/camera_device_hwl.h
@@ -58,6 +58,17 @@ class CameraDeviceHwl {
   // unchanged after this CameraDevice instance is destroyed.
   virtual status_t SetTorchMode(TorchMode mode) = 0;
 
+  // Change the torch strength level of this camera device. If the torch is OFF
+  // and torchStrength > 0, then the torch will turn ON.
+  virtual status_t TurnOnTorchWithStrengthLevel(int32_t /*torch_strength*/) {
+    return UNKNOWN_TRANSACTION;
+  }
+
+  // Get the torch strength level of this camera device HWL.
+  virtual status_t GetTorchStrengthLevel(int32_t& /*torch_strength*/) const {
+    return UNKNOWN_TRANSACTION;
+  }
+
   // Dump the camera device states in fd, using dprintf() or write().
   virtual status_t DumpState(int fd) = 0;
 
diff --git a/common/hal/hwl_interface/camera_device_session_hwl.h b/common/hal/hwl_interface/camera_device_session_hwl.h
index 0dcfebd..c8094a5 100644
--- a/common/hal/hwl_interface/camera_device_session_hwl.h
+++ b/common/hal/hwl_interface/camera_device_session_hwl.h
@@ -122,6 +122,13 @@ class CameraDeviceSessionHwl {
   // this method should return an empty std::vector.
   virtual std::vector<uint32_t> GetPhysicalCameraIds() const = 0;
 
+  // Returns true if the two given physical camera ids can be streamed
+  // simultaneously from this device session.
+  virtual bool CanStreamSimultaneously(uint32_t /* physical_camera_id_1 */,
+                                       uint32_t /* physical_camera_id_2 */) const {
+    return true;
+  }
+
   // Return the characteristics that this camera device session is associated with.
   virtual status_t GetCameraCharacteristics(
       std::unique_ptr<HalCameraMetadata>* characteristics) const = 0;
@@ -165,11 +172,23 @@ class CameraDeviceSessionHwl {
   // Get zoom ratio mapper from HWL.
   virtual std::unique_ptr<ZoomRatioMapperHwl> GetZoomRatioMapperHwl() = 0;
 
+  // Get maximum number of cameras allowed to stream concurrently.
+  virtual int GetMaxSupportedConcurrentCameras() const {
+    return 1;
+  }
+
   // Get customized profiler
   virtual std::unique_ptr<google::camera_common::Profiler> GetProfiler(
       uint32_t /* camera_id */, int /* option */) {
     return nullptr;
   }
+
+  // Release unused framework buffers from cache. This should be called when a
+  // ProcessCaptureRequest call includes a non-empty cachesToRemove argument. It
+  // is used to pass the list of buffers to the HWL to handle any internal
+  // caching of file descriptors done by the HWL.
+  virtual void RemoveCachedBuffers(const native_handle_t* /*handle*/) {
+  }
 };
 
 }  // namespace google_camera_hal
diff --git a/common/hal/hwl_interface/process_block.h b/common/hal/hwl_interface/process_block.h
index 8303aba..455dadd 100644
--- a/common/hal/hwl_interface/process_block.h
+++ b/common/hal/hwl_interface/process_block.h
@@ -113,6 +113,9 @@ class ExternalProcessBlockFactory {
 #if !GCH_HWL_USE_DLOPEN
 extern "C" __attribute__((weak)) ExternalProcessBlockFactory*
 GetSnapshotProcessBlockFactory();
+
+extern "C" __attribute__((weak)) ExternalProcessBlockFactory*
+GetDenoiseProcessBlockFactory();
 #endif
 
 }  // namespace google_camera_hal
diff --git a/common/hal/tests/camera_device_tests.cc b/common/hal/tests/camera_device_tests.cc
index c7ec3e6..3b0e6e4 100644
--- a/common/hal/tests/camera_device_tests.cc
+++ b/common/hal/tests/camera_device_tests.cc
@@ -94,6 +94,20 @@ TEST(CameraDeviceTests, SetTorchMode) {
   EXPECT_EQ(device->SetTorchMode(TorchMode::kOn), OK);
 }
 
+TEST(CameraDeviceTests, TurnOnTorchWithStrengthLevel) {
+  auto mock_device_hwl = MockDeviceHwl::Create();
+  ASSERT_NE(mock_device_hwl, nullptr);
+  int32_t new_torch_strength = 5;
+
+  auto device = CameraDevice::Create(std::move(mock_device_hwl));
+  ASSERT_NE(device, nullptr);
+
+  EXPECT_EQ(device->TurnOnTorchWithStrengthLevel(new_torch_strength), OK);
+  int32_t torch_strength = 0;
+  EXPECT_EQ(device->GetTorchStrengthLevel(torch_strength), OK);
+  EXPECT_EQ(torch_strength, new_torch_strength);
+}
+
 TEST(CameraDeviceTests, DumpState) {
   auto mock_device_hwl = MockDeviceHwl::Create();
   ASSERT_NE(mock_device_hwl, nullptr);
diff --git a/common/hal/tests/mock_device_hwl.h b/common/hal/tests/mock_device_hwl.h
index 18b7ef4..f36015b 100644
--- a/common/hal/tests/mock_device_hwl.h
+++ b/common/hal/tests/mock_device_hwl.h
@@ -83,6 +83,20 @@ class MockDeviceHwl : public CameraDeviceHwl {
     return OK;
   }
 
+   status_t TurnOnTorchWithStrengthLevel(int32_t torch_strength) {
+    if (torch_strength < 1) {
+      return BAD_VALUE;
+    }
+
+    torch_strength_ = torch_strength;
+    return OK;
+  }
+
+  status_t GetTorchStrengthLevel(int32_t& torch_strength) const {
+    torch_strength = torch_strength_;
+    return OK;
+  }
+
   // Dump the camera device states in fd, using dprintf() or write().
   status_t DumpState(int fd) {
     if (fd < 0) {
@@ -132,6 +146,7 @@ class MockDeviceHwl : public CameraDeviceHwl {
       physical_camera_characteristics_;
 
   std::string dump_string_;
+  int32_t torch_strength_ = 0;
 
  protected:
   MockDeviceHwl() {
diff --git a/common/hal/tests/mock_device_session_hwl.cc b/common/hal/tests/mock_device_session_hwl.cc
index 43e914e..5a8af01 100644
--- a/common/hal/tests/mock_device_session_hwl.cc
+++ b/common/hal/tests/mock_device_session_hwl.cc
@@ -183,6 +183,7 @@ status_t FakeCameraDeviceSessionHwl::SubmitRequests(
                                      .message.shutter = {
                                          .frame_number = frame_number,
                                          .timestamp_ns = 0,
+                                         .readout_timestamp_ns = 0,
                                      }};
     callback->second.notify(request.pipeline_id, shutter_message);
 
diff --git a/common/hal/tests/result_dispatcher_tests.cc b/common/hal/tests/result_dispatcher_tests.cc
index 75df29e..7196767 100644
--- a/common/hal/tests/result_dispatcher_tests.cc
+++ b/common/hal/tests/result_dispatcher_tests.cc
@@ -309,14 +309,17 @@ class ResultDispatcherTests : public ::testing::Test {
 
 TEST_F(ResultDispatcherTests, ShutterOrder) {
   static constexpr uint64_t kFrameDurationNs = 100;
+  static constexpr uint64_t kFrameExposureTimeNs = 33;
 
   std::vector<uint32_t> unordered_frame_numbers = {3, 1, 2, 5, 4, 6};
   AddPendingRequestsToDispatcher(unordered_frame_numbers);
 
   // Add unordered shutters to dispatcher.
   for (auto frame_number : unordered_frame_numbers) {
-    EXPECT_EQ(result_dispatcher_->AddShutter(frame_number,
-                                             frame_number * kFrameDurationNs),
+    EXPECT_EQ(result_dispatcher_->AddShutter(
+                  frame_number,
+                  frame_number * kFrameDurationNs - kFrameExposureTimeNs,
+                  frame_number * kFrameDurationNs),
               OK);
   }
 
@@ -398,6 +401,7 @@ TEST_F(ResultDispatcherTests, OutputBufferOrder) {
 
 TEST_F(ResultDispatcherTests, ShutterOrderWithRemovePengingRequest) {
   static constexpr uint64_t kFrameDurationNs = 100;
+  static constexpr uint64_t kFrameExposureTimeNs = 33;
 
   std::vector<uint32_t> unordered_frame_numbers = {3, 1, 2, 5, 4, 6};
   AddPendingRequestsToDispatcher(unordered_frame_numbers);
@@ -407,8 +411,10 @@ TEST_F(ResultDispatcherTests, ShutterOrderWithRemovePengingRequest) {
   // After erase iter, unordered_frame_numbers = {3, 1, 5, 4, 6};
   unordered_frame_numbers.erase(iter);
   for (auto frame_number : unordered_frame_numbers) {
-    EXPECT_EQ(result_dispatcher_->AddShutter(frame_number,
-                                             frame_number * kFrameDurationNs),
+    EXPECT_EQ(result_dispatcher_->AddShutter(
+                  frame_number,
+                  frame_number * kFrameDurationNs - kFrameExposureTimeNs,
+                  frame_number * kFrameDurationNs),
               OK);
   }
 
diff --git a/common/hal/utils/camera_blob.h b/common/hal/utils/camera_blob.h
new file mode 100644
index 0000000..f038b55
--- /dev/null
+++ b/common/hal/utils/camera_blob.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARDWARE_GOOGLE_CAMERA_HAL_UTILS_CAMERA_BLOB_H_
+#define HARDWARE_GOOGLE_CAMERA_HAL_UTILS_CAMERA_BLOB_H_
+
+#include <cstdint>
+
+namespace android {
+namespace google_camera_hal {
+
+/**
+ * CameraBlob:
+ *
+ * Transport header for camera blob types; generally compressed JPEG buffers in
+ * output streams.
+ *
+ * To capture JPEG images, a stream is created using the pixel format
+ * HAL_PIXEL_FORMAT_BLOB and dataspace HAL_DATASPACE_V0_JFIF. The buffer size
+ * for the stream is calculated by the framework, based on the static metadata
+ * field android.jpeg.maxSize. Since compressed JPEG images are of variable
+ * size, the HAL needs to include the final size of the compressed image using
+ * this structure inside the output stream buffer. The camera blob ID field must
+ * be set to CameraBlobId::JPEG.
+ *
+ * The transport header must be at the end of the JPEG output stream
+ * buffer. That means the jpegBlobId must start at byte[buffer_size -
+ * sizeof(CameraBlob)], where the buffer_size is the size of gralloc
+ * buffer. Any HAL using this transport header must account for it in
+ * android.jpeg.maxSize. The JPEG data itself starts at the beginning of the
+ * buffer and must be blobSize bytes long.
+ *
+ * Copied from hardware/interfaces/camera/device/aidl/CameraBlobId.aidl
+ */
+enum CameraBlobId : uint32_t {
+  JPEG = 0x00FF,
+};
+
+struct CameraBlob {
+  CameraBlobId blob_id;
+  uint32_t blob_size;
+};
+
+}  // namespace google_camera_hal
+}  // namespace android
+
+#endif  // HARDWARE_GOOGLE_CAMERA_HAL_UTILS_CAMERA_BLOB_H_
diff --git a/common/hal/utils/hal_utils.cc b/common/hal/utils/hal_utils.cc
index e45e179..58febe7 100644
--- a/common/hal/utils/hal_utils.cc
+++ b/common/hal/utils/hal_utils.cc
@@ -743,6 +743,8 @@ void DumpNotify(const NotifyMessage& message, const std::string& title) {
   if (message.type == MessageType::kShutter) {
     ALOGI("== frame_number:%u", message.message.shutter.frame_number);
     ALOGI("== time_stamp:%" PRIu64, message.message.shutter.timestamp_ns);
+    ALOGI("== readout_time_stamp:%" PRIu64,
+          message.message.shutter.readout_timestamp_ns);
   } else if (message.type == MessageType::kError) {
     ALOGI("== frame_number:%u", message.message.error.frame_number);
     ALOGI("== error_code:%u", message.message.error.error_code);
diff --git a/common/hal/utils/result_dispatcher.cc b/common/hal/utils/result_dispatcher.cc
index 6de6863..0a4832c 100644
--- a/common/hal/utils/result_dispatcher.cc
+++ b/common/hal/utils/result_dispatcher.cc
@@ -237,28 +237,32 @@ status_t ResultDispatcher::AddResult(std::unique_ptr<CaptureResult> result) {
 }
 
 status_t ResultDispatcher::AddShutter(uint32_t frame_number,
-                                      int64_t timestamp_ns) {
+                                      int64_t timestamp_ns,
+                                      int64_t readout_timestamp_ns) {
   ATRACE_CALL();
-  std::lock_guard<std::mutex> lock(result_lock_);
+  {
+    std::lock_guard<std::mutex> lock(result_lock_);
 
-  auto shutter_it = pending_shutters_.find(frame_number);
-  if (shutter_it == pending_shutters_.end()) {
-    ALOGE("%s: Cannot find the pending shutter for frame %u", __FUNCTION__,
-          frame_number);
-    return NAME_NOT_FOUND;
-  }
+    auto shutter_it = pending_shutters_.find(frame_number);
+    if (shutter_it == pending_shutters_.end()) {
+      ALOGE("%s: Cannot find the pending shutter for frame %u", __FUNCTION__,
+            frame_number);
+      return NAME_NOT_FOUND;
+    }
 
-  if (shutter_it->second.ready) {
-    ALOGE("%s: Already received shutter (%" PRId64
-          ") for frame %u. New "
-          "timestamp %" PRId64,
-          __FUNCTION__, shutter_it->second.timestamp_ns, frame_number,
-          timestamp_ns);
-    return ALREADY_EXISTS;
-  }
+    if (shutter_it->second.ready) {
+      ALOGE("%s: Already received shutter (%" PRId64
+            ") for frame %u. New "
+            "timestamp %" PRId64,
+            __FUNCTION__, shutter_it->second.timestamp_ns, frame_number,
+            timestamp_ns);
+      return ALREADY_EXISTS;
+    }
 
-  shutter_it->second.timestamp_ns = timestamp_ns;
-  shutter_it->second.ready = true;
+    shutter_it->second.timestamp_ns = timestamp_ns;
+    shutter_it->second.readout_timestamp_ns = readout_timestamp_ns;
+    shutter_it->second.ready = true;
+  }
   {
     std::unique_lock<std::mutex> lock(notify_callback_lock_);
     is_result_shutter_updated_ = true;
@@ -451,6 +455,8 @@ status_t ResultDispatcher::GetReadyShutterMessage(NotifyMessage* message) {
   message->type = MessageType::kShutter;
   message->message.shutter.frame_number = shutter_it->first;
   message->message.shutter.timestamp_ns = shutter_it->second.timestamp_ns;
+  message->message.shutter.readout_timestamp_ns =
+      shutter_it->second.readout_timestamp_ns;
   pending_shutters_.erase(shutter_it);
 
   return OK;
@@ -464,9 +470,11 @@ void ResultDispatcher::NotifyShutters() {
     if (GetReadyShutterMessage(&message) != OK) {
       break;
     }
-    ALOGV("%s: Notify shutter for frame %u timestamp %" PRIu64, __FUNCTION__,
-          message.message.shutter.frame_number,
-          message.message.shutter.timestamp_ns);
+    ALOGV("%s: Notify shutter for frame %u timestamp %" PRIu64
+          " readout_timestamp %" PRIu64,
+          __FUNCTION__, message.message.shutter.frame_number,
+          message.message.shutter.timestamp_ns,
+          message.message.shutter.readout_timestamp_ns);
     notify_(message);
   }
 }
diff --git a/common/hal/utils/result_dispatcher.h b/common/hal/utils/result_dispatcher.h
index 0d94ec8..19e7c9e 100644
--- a/common/hal/utils/result_dispatcher.h
+++ b/common/hal/utils/result_dispatcher.h
@@ -56,7 +56,8 @@ class ResultDispatcher {
   // Add a shutter for a frame number. If the frame number doesn't belong to a
   // pending request that was previously added via AddPendingRequest(), an error
   // will be returned.
-  status_t AddShutter(uint32_t frame_number, int64_t timestamp_ns);
+  status_t AddShutter(uint32_t frame_number, int64_t timestamp_ns,
+                      int64_t readout_timestamp_ns);
 
   // Add an error notification for a frame number. When this is called, we no
   // longer wait for a shutter message or result metadata for the given frame.
@@ -77,6 +78,7 @@ class ResultDispatcher {
   // called.
   struct PendingShutter {
     int64_t timestamp_ns = 0;
+    int64_t readout_timestamp_ns = 0;
     bool ready = false;
   };
 
diff --git a/common/hal/utils/utils.cc b/common/hal/utils/utils.cc
index 7a41889..6e0ba2f 100644
--- a/common/hal/utils/utils.cc
+++ b/common/hal/utils/utils.cc
@@ -486,6 +486,40 @@ std::vector<std::string> FindLibraryPaths(const char* dir_path) {
   return libs;
 }
 
+bool IsStreamUseCaseSupported(const StreamConfiguration& stream_config,
+                              const std::set<int64_t>& stream_use_cases,
+                              bool log_if_not_supported) {
+  for (const auto& stream : stream_config.streams) {
+    if (stream_use_cases.find(stream.use_case) == stream_use_cases.end()) {
+      if (log_if_not_supported) {
+        ALOGE("Stream use case %d not in set of supported use cases",
+              stream.use_case);
+      }
+      return false;
+    }
+  }
+  return true;
+}
+
+status_t GetStreamUseCases(const HalCameraMetadata* static_metadata,
+                           std::set<int64_t>* stream_use_cases) {
+  if (static_metadata == nullptr || stream_use_cases == nullptr) {
+    return BAD_VALUE;
+  }
+
+  camera_metadata_ro_entry entry;
+  status_t ret =
+      static_metadata->Get(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES, &entry);
+  if (ret != OK) {
+    ALOGV("%s: No available stream use cases!", __FUNCTION__);
+    stream_use_cases->insert(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT);
+    return OK;
+  }
+  stream_use_cases->insert(entry.data.i64, entry.data.i64 + entry.count);
+
+  return OK;
+}
+
 }  // namespace utils
 }  // namespace google_camera_hal
 }  // namespace android
diff --git a/common/hal/utils/utils.h b/common/hal/utils/utils.h
index a43e614..699be9d 100644
--- a/common/hal/utils/utils.h
+++ b/common/hal/utils/utils.h
@@ -19,6 +19,7 @@
 
 #include <log/log.h>
 
+#include <set>
 #include <utility>
 
 #include "hal_types.h"
@@ -77,6 +78,13 @@ status_t SetRealtimeThread(pthread_t thread);
 status_t UpdateThreadSched(pthread_t thread, int32_t policy,
                            struct sched_param* param);
 
+status_t GetStreamUseCases(const HalCameraMetadata* static_metadata,
+                           std::set<int64_t>* stream_use_cases);
+
+bool IsStreamUseCaseSupported(const StreamConfiguration& stream_config,
+                              const std::set<int64_t>& stream_use_cases,
+                              bool log_if_not_supported = true);
+
 // Map the rectangle to the coordination of HAL.
 void ConvertZoomRatio(float zoom_ratio, const Dimension& active_array_dimension,
                       int32_t* left, int32_t* top, int32_t* width,
diff --git a/common/hal/utils/zsl_result_dispatcher.cc b/common/hal/utils/zsl_result_dispatcher.cc
index 3b5baa4..e74d803 100644
--- a/common/hal/utils/zsl_result_dispatcher.cc
+++ b/common/hal/utils/zsl_result_dispatcher.cc
@@ -143,13 +143,16 @@ status_t ZslResultDispatcher::AddResult(std::unique_ptr<CaptureResult> result) {
 }
 
 status_t ZslResultDispatcher::AddShutter(uint32_t frame_number,
-                                         int64_t timestamp_ns) {
+                                         int64_t timestamp_ns,
+                                         int64_t readout_timestamp_ns) {
   ATRACE_CALL();
   bool is_zsl_request = IsZslFrame(frame_number);
   if (is_zsl_request) {
-    return zsl_result_dispatcher_->AddShutter(frame_number, timestamp_ns);
+    return zsl_result_dispatcher_->AddShutter(frame_number, timestamp_ns,
+                                              readout_timestamp_ns);
   } else {
-    return normal_result_dispatcher_->AddShutter(frame_number, timestamp_ns);
+    return normal_result_dispatcher_->AddShutter(frame_number, timestamp_ns,
+                                                 readout_timestamp_ns);
   }
 }
 
diff --git a/common/hal/utils/zsl_result_dispatcher.h b/common/hal/utils/zsl_result_dispatcher.h
index 6297b6b..562ba38 100644
--- a/common/hal/utils/zsl_result_dispatcher.h
+++ b/common/hal/utils/zsl_result_dispatcher.h
@@ -63,7 +63,8 @@ class ZslResultDispatcher {
   // Add a shutter for a frame number. If the frame number doesn't belong to a
   // pending request that was previously added via AddPendingRequest(), an error
   // will be returned.
-  status_t AddShutter(uint32_t frame_number, int64_t timestamp_ns);
+  status_t AddShutter(uint32_t frame_number, int64_t timestamp_ns,
+                      int64_t readout_timestamp_ns);
 
   // Add an error notification for a frame number. When this is called, we no
   // longer wait for a shutter message or result metadata for the given frame.
diff --git a/common/profiler/profiler.cc b/common/profiler/profiler.cc
index 31fdaa6..689ef35 100644
--- a/common/profiler/profiler.cc
+++ b/common/profiler/profiler.cc
@@ -95,8 +95,11 @@ class ProfilerImpl : public Profiler {
   void SetFpsPrintInterval(int32_t interval_seconds) override final;
 
   // Get the latency associated with the name
-  int64_t GetLatencyInNanoseconds(const std::string& name,
-                                  int request_id) override final;
+  std::list<std::pair<std::string, float>> GetLatencyData() override final;
+
+  std::string GetUseCase() const override final {
+    return use_case_;
+  }
 
  protected:
   // A structure to hold start time, end time, and count of profiling code
@@ -496,19 +499,26 @@ void ProfilerImpl::DumpPb(std::string_view filepath) {
 }
 
 // Get the latency associated with the name
-int64_t ProfilerImpl::GetLatencyInNanoseconds(const std::string& name,
-                                              int request_id) {
-  // Will use name to add various TraceInt64 here
-  int valid_request_id = (request_id == kInvalidRequestId) ? 0 : request_id + 1;
-  int64_t latency_ns = 0;
-  {
-    std::lock_guard<std::mutex> lk(lock_);
-    if (static_cast<std::size_t>(valid_request_id) < timing_map_[name].size()) {
-      TimeSlot& slot = timing_map_[name][valid_request_id];
-      latency_ns = slot.end - slot.start;
+std::list<std::pair<std::string, float>> ProfilerImpl::GetLatencyData() {
+  std::list<std::pair<std::string, TimeSlot>> time_results;
+  std::list<std::pair<std::string, float>> latency_data;
+  for (const auto& [node_name, time_series] : timing_map_) {
+    for (const auto& slot : time_series) {
+      if (slot.count > 0 && time_results.size() < time_results.max_size()) {
+        time_results.push_back({node_name, slot});
+      }
     }
   }
-  return latency_ns;
+  time_results.sort(
+      [](const auto& a, const auto& b) { return a.second.end < b.second.end; });
+
+  for (const auto& [node_name, slot] : time_results) {
+    if (slot.count > 0) {
+      float elapsed = (slot.end - slot.start) * kNanoToMilli;
+      latency_data.push_back({node_name, elapsed});
+    }
+  }
+  return latency_data;
 }
 
 class ProfilerStopwatchImpl : public ProfilerImpl {
@@ -588,8 +598,11 @@ class ProfilerDummy : public Profiler {
   void PrintResult() override final{};
   void ProfileFrameRate(const std::string&) override final{};
   void SetFpsPrintInterval(int32_t) override final{};
-  int64_t GetLatencyInNanoseconds(const std::string&, int) override final {
-    return 0;
+  std::list<std::pair<std::string, float>> GetLatencyData() override final {
+    return {};
+  }
+  std::string GetUseCase() const override final {
+    return "";
   }
 };
 
diff --git a/common/profiler/profiler.h b/common/profiler/profiler.h
index 9e8f16f..8788e59 100644
--- a/common/profiler/profiler.h
+++ b/common/profiler/profiler.h
@@ -20,6 +20,7 @@
 #include <cutils/properties.h>
 
 #include <limits>
+#include <list>
 #include <memory>
 #include <string>
 
@@ -207,8 +208,9 @@ class Profiler {
   // The interval unit is second and interval_seconds must >= 1
   virtual void SetFpsPrintInterval(int32_t interval_seconds) = 0;
 
-  virtual int64_t GetLatencyInNanoseconds(const std::string& name,
-                                          int request_id) = 0;
+  virtual std::list<std::pair<std::string, float>> GetLatencyData() = 0;
+
+  virtual std::string GetUseCase() const = 0;
 
  protected:
   Profiler() = default;
diff --git a/devices/EmulatedCamera/OWNERS b/devices/EmulatedCamera/OWNERS
new file mode 100644
index 0000000..f57f3f5
--- /dev/null
+++ b/devices/EmulatedCamera/OWNERS
@@ -0,0 +1,2 @@
+# Bug component: 41727
+include platform/frameworks/av:/camera/OWNERS
\ No newline at end of file
diff --git a/devices/EmulatedCamera/hwl/Android.bp b/devices/EmulatedCamera/hwl/Android.bp
index cf276ec..fad5ef0 100644
--- a/devices/EmulatedCamera/hwl/Android.bp
+++ b/devices/EmulatedCamera/hwl/Android.bp
@@ -14,13 +14,8 @@ cc_defaults {
         "EmulatedLogicalRequestState.cpp",
         "EmulatedRequestProcessor.cpp",
         "EmulatedRequestState.cpp",
-        "EmulatedScene.cpp",
-        "EmulatedSensor.cpp",
         "EmulatedTorchState.cpp",
-        "JpegCompressor.cpp",
-        "utils/ExifUtils.cpp",
-        "utils/HWLUtils.cpp",
-        "utils/StreamConfigurationMap.cpp",
+        "GrallocSensorBuffer.cpp",
     ],
     cflags: [
         "-Werror",
@@ -56,6 +51,7 @@ cc_defaults {
     ],
     static_libs: [
         "android.hardware.camera.common@1.0-helper",
+        "libgooglecamerahwl_sensor_impl",
     ],
     include_dirs: [
         "system/media/private/camera/include",
@@ -78,3 +74,52 @@ cc_library_shared {
     // Never installed to /vendor, only used inside an APEX.
     installable: false,
 }
+
+cc_library_static {
+    name: "libgooglecamerahwl_sensor_impl",
+    owner: "google",
+    proprietary: true,
+    host_supported: true,
+
+    srcs: [
+        "EmulatedScene.cpp",
+        "EmulatedSensor.cpp",
+        "JpegCompressor.cpp",
+        "utils/ExifUtils.cpp",
+        "utils/HWLUtils.cpp",
+        "utils/StreamConfigurationMap.cpp",
+    ],
+
+    header_libs: [
+        "libhardware_headers",
+    ],
+
+    shared_libs: [
+        "libcamera_metadata",
+        "libcutils",
+        "libexif",
+        "libjpeg",
+        "liblog",
+        "libyuv",
+    ],
+
+    static_libs: [
+        "android.hardware.graphics.common@1.1",
+        "android.hardware.graphics.common@1.2",
+    ],
+
+    include_dirs: [
+        "system/media/private/camera/include",
+        "hardware/google/camera/common/hal/common",
+        "hardware/google/camera/common/hal/hwl_interface",
+        "hardware/google/camera/common/hal/utils",
+    ],
+
+    export_include_dirs: ["."],
+
+    cflags: [
+        "-Werror",
+        "-Wextra",
+        "-Wall",
+    ],
+}
diff --git a/devices/EmulatedCamera/hwl/Base.h b/devices/EmulatedCamera/hwl/Base.h
index 883b61a..c6722a5 100644
--- a/devices/EmulatedCamera/hwl/Base.h
+++ b/devices/EmulatedCamera/hwl/Base.h
@@ -21,12 +21,11 @@
 
 #include <memory>
 
-#include "HandleImporter.h"
+#include "android/hardware/graphics/common/1.1/types.h"
 #include "hwl_types.h"
 
 namespace android {
 
-using android::hardware::camera::common::V1_0::helper::HandleImporter;
 using android::hardware::graphics::common::V1_1::PixelFormat;
 using google_camera_hal::HwlPipelineCallback;
 using google_camera_hal::StreamBuffer;
@@ -55,7 +54,6 @@ struct SensorBuffer {
   PixelFormat format;
   android_dataspace_t dataSpace;
   StreamBuffer stream_buffer;
-  std::shared_ptr<HandleImporter> importer;
   HwlPipelineCallback callback;
   int acquire_fence_fd;
   bool is_input;
@@ -66,7 +64,7 @@ struct SensorBuffer {
     YCbCrPlanes img_y_crcb;
   } plane;
 
-  SensorBuffer(std::shared_ptr<HandleImporter> handle_importer)
+  SensorBuffer()
       : width(0),
         height(0),
         frame_number(0),
@@ -74,7 +72,6 @@ struct SensorBuffer {
         camera_id(0),
         format(PixelFormat::RGBA_8888),
         dataSpace(HAL_DATASPACE_UNKNOWN),
-        importer(handle_importer),
         acquire_fence_fd(-1),
         is_input(false),
         is_failed_request(false),
@@ -83,59 +80,13 @@ struct SensorBuffer {
 
   SensorBuffer(const SensorBuffer&) = delete;
   SensorBuffer& operator=(const SensorBuffer&) = delete;
+
+  virtual ~SensorBuffer() {
+  }
 };
 
 typedef std::vector<std::unique_ptr<SensorBuffer>> Buffers;
 
 }  // namespace android
 
-using android::google_camera_hal::BufferStatus;
-using android::google_camera_hal::ErrorCode;
-using android::google_camera_hal::HwlPipelineResult;
-using android::google_camera_hal::MessageType;
-using android::google_camera_hal::NotifyMessage;
-
-template <>
-struct std::default_delete<android::SensorBuffer> {
-  inline void operator()(android::SensorBuffer* buffer) const {
-    if (buffer != nullptr) {
-      if (buffer->stream_buffer.buffer != nullptr) {
-        buffer->importer->unlock(buffer->stream_buffer.buffer);
-      }
-
-      if (buffer->acquire_fence_fd >= 0) {
-        buffer->importer->closeFence(buffer->acquire_fence_fd);
-      }
-
-      if ((buffer->stream_buffer.status != BufferStatus::kOk) &&
-          (buffer->callback.notify != nullptr) && (!buffer->is_failed_request)) {
-        NotifyMessage msg = {
-            .type = MessageType::kError,
-            .message.error = {.frame_number = buffer->frame_number,
-                              .error_stream_id = buffer->stream_buffer.stream_id,
-                              .error_code = ErrorCode::kErrorBuffer}};
-        buffer->callback.notify(buffer->pipeline_id, msg);
-      }
-
-      if (buffer->callback.process_pipeline_result != nullptr) {
-        auto result = std::make_unique<HwlPipelineResult>();
-        result->camera_id = buffer->camera_id;
-        result->pipeline_id = buffer->pipeline_id;
-        result->frame_number = buffer->frame_number;
-        result->partial_result = 0;
-
-        buffer->stream_buffer.acquire_fence =
-            buffer->stream_buffer.release_fence = nullptr;
-        if (buffer->is_input) {
-          result->input_buffers.push_back(buffer->stream_buffer);
-        } else {
-          result->output_buffers.push_back(buffer->stream_buffer);
-        }
-        buffer->callback.process_pipeline_result(std::move(result));
-      }
-      delete buffer;
-    }
-  }
-};
-
 #endif
diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.cpp b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.cpp
index f6ffaee..75a55af 100644
--- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.cpp
@@ -99,6 +99,9 @@ status_t EmulatedCameraDeviceHwlImpl::Initialize() {
       return ret;
     }
   }
+
+  default_torch_strength_level_ = GetDefaultTorchStrengthLevel();
+  maximum_torch_strength_level_ = GetMaximumTorchStrengthLevel();
   return OK;
 }
 
@@ -151,9 +154,46 @@ status_t EmulatedCameraDeviceHwlImpl::SetTorchMode(TorchMode mode) {
     return INVALID_OPERATION;
   }
 
+  // If torch strength control is supported, reset the torch strength level to
+  // default level whenever the torch is turned OFF.
+  if (maximum_torch_strength_level_ > 1) {
+    torch_state_->InitializeTorchDefaultLevel(default_torch_strength_level_);
+    torch_state_->InitializeSupportTorchStrengthLevel(true);
+  }
+
   return torch_state_->SetTorchMode(mode);
 }
 
+status_t EmulatedCameraDeviceHwlImpl::TurnOnTorchWithStrengthLevel(int32_t torch_strength) {
+  if (torch_state_.get() == nullptr) {
+    return UNKNOWN_TRANSACTION;
+  }
+
+  // This API is supported if the maximum level is set to greater than 1.
+  if (maximum_torch_strength_level_ <= 1) {
+    ALOGE("Torch strength control feature is not supported.");
+    return UNKNOWN_TRANSACTION;
+  }
+  // Validate that the torch_strength is within the range.
+  if (torch_strength > maximum_torch_strength_level_ || torch_strength < 1) {
+    ALOGE("Torch strength value should be within the range.");
+    return BAD_VALUE;
+  }
+
+  return torch_state_->TurnOnTorchWithStrengthLevel(torch_strength);
+}
+
+status_t EmulatedCameraDeviceHwlImpl::GetTorchStrengthLevel(int32_t& torch_strength) const {
+  if (default_torch_strength_level_ < 1 && maximum_torch_strength_level_ <= 1) {
+    ALOGE("Torch strength control feature is not supported.");
+    return UNKNOWN_TRANSACTION;
+  }
+
+  torch_strength = torch_state_->GetTorchStrengthLevel();
+  ALOGV("Current torch strength level is: %d", torch_strength);
+  return OK;
+}
+
 status_t EmulatedCameraDeviceHwlImpl::DumpState(int /*fd*/) {
   return OK;
 }
@@ -192,4 +232,26 @@ bool EmulatedCameraDeviceHwlImpl::IsStreamCombinationSupported(
       physical_stream_configuration_map_max_resolution_, sensor_chars_);
 }
 
+int32_t EmulatedCameraDeviceHwlImpl::GetDefaultTorchStrengthLevel() const {
+  camera_metadata_ro_entry entry;
+  int32_t default_level = 0;
+  auto ret = static_metadata_->Get(ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL, &entry);
+  if (ret == OK && (entry.count == 1)) {
+     default_level = *entry.data.i32;
+     ALOGV("Default torch strength level is %d", default_level);
+  }
+  return default_level;
+}
+
+int32_t EmulatedCameraDeviceHwlImpl::GetMaximumTorchStrengthLevel() const {
+  camera_metadata_ro_entry entry;
+  int32_t max_level = 0;
+  auto ret = static_metadata_->Get(ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL, &entry);
+  if (ret == OK && (entry.count == 1)) {
+     max_level = *entry.data.i32;
+     ALOGV("Maximum torch strength level is %d", max_level);
+  }
+  return max_level;
+}
+
 }  // namespace android
diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.h b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.h
index c88b804..08c6ba3 100644
--- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.h
+++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceHWLImpl.h
@@ -58,6 +58,10 @@ class EmulatedCameraDeviceHwlImpl : public CameraDeviceHwl {
 
   status_t SetTorchMode(TorchMode mode) override;
 
+  status_t TurnOnTorchWithStrengthLevel(int32_t torch_strength) override;
+
+  status_t GetTorchStrengthLevel(int32_t& torch_strength) const override;
+
   status_t DumpState(int fd) override;
 
   status_t CreateCameraDeviceSessionHwl(
@@ -77,6 +81,9 @@ class EmulatedCameraDeviceHwlImpl : public CameraDeviceHwl {
 
   status_t Initialize();
 
+  int32_t GetDefaultTorchStrengthLevel() const;
+  int32_t GetMaximumTorchStrengthLevel() const;
+
   const uint32_t camera_id_ = 0;
 
   std::unique_ptr<HalCameraMetadata> static_metadata_;
@@ -87,6 +94,9 @@ class EmulatedCameraDeviceHwlImpl : public CameraDeviceHwl {
   PhysicalDeviceMapPtr physical_device_map_;
   std::shared_ptr<EmulatedTorchState> torch_state_;
   LogicalCharacteristics sensor_chars_;
+  int32_t default_torch_strength_level_ = 0;
+  int32_t maximum_torch_strength_level_ = 0;
+
 };
 
 }  // namespace android
diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp
index ee6461b..fb46544 100644
--- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp
@@ -18,11 +18,14 @@
 
 #include "EmulatedCameraDeviceSessionHWLImpl.h"
 
+#include <android/hardware/graphics/common/1.2/types.h>
 #include <hardware/gralloc.h>
 #include <inttypes.h>
 #include <log/log.h>
 #include <utils/Trace.h>
 
+#include <memory>
+
 #include "EmulatedSensor.h"
 #include "utils.h"
 #include "utils/HWLUtils.h"
@@ -33,6 +36,7 @@ using google_camera_hal::Rect;
 using google_camera_hal::utils::GetSensorActiveArraySize;
 using google_camera_hal::utils::HasCapability;
 
+using android::hardware::graphics::common::V1_2::Dataspace;
 std::unique_ptr<EmulatedCameraZoomRatioMapperHwlImpl>
 EmulatedCameraZoomRatioMapperHwlImpl::Create(
     const std::unordered_map<uint32_t, std::pair<Dimension, Dimension>>& dims) {
@@ -202,9 +206,11 @@ status_t EmulatedCameraDeviceSessionHwlImpl::InitializeRequestProcessor() {
     return ret;
   }
 
-  request_processor_ = std::make_unique<EmulatedRequestProcessor>(
+  request_processor_ = std::make_shared<EmulatedRequestProcessor>(
       camera_id_, emulated_sensor, session_callback_);
 
+  request_processor_->InitializeSensorQueue(request_processor_);
+
   return request_processor_->Initialize(
       HalCameraMetadata::Clone(static_metadata_.get()),
       ClonePhysicalDeviceMap(physical_device_map_));
@@ -274,20 +280,29 @@ status_t EmulatedCameraDeviceSessionHwlImpl::ConfigurePipeline(
             {{.id = stream.id,
               .override_format =
                   is_input ? stream.format
-                           : EmulatedSensor::OverrideFormat(stream.format),
+                           : EmulatedSensor::OverrideFormat(
+                                 stream.format, stream.dynamic_profile),
               .producer_usage = is_input ? 0
                                          : GRALLOC_USAGE_HW_CAMERA_WRITE |
                                                GRALLOC_USAGE_HW_CAMERA_READ,
               .consumer_usage = 0,
               .max_buffers = max_pipeline_depth_,
-              .override_data_space = stream.data_space,
+              .override_data_space =
+                  (stream.dynamic_profile ==
+                   ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10) &&
+                          (stream.format ==
+                           HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)
+                      ? static_cast<android_dataspace_t>(
+                            Dataspace::BT2020_ITU_HLG)
+                      : stream.data_space,
               .is_physical_camera_stream = stream.is_physical_camera_stream,
               .physical_camera_id = stream.physical_camera_id},
              .width = stream.width,
              .height = stream.height,
              .buffer_size = stream.buffer_size,
              .is_input = is_input,
-             .group_id = stream.group_id}));
+             .group_id = stream.group_id,
+             .use_case = stream.use_case}));
 
     if (stream.group_id != -1 && stream.is_physical_camera_stream) {
       // TODO: For quad bayer camera, the logical camera id should be used if
diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h
index 52a4920..81631cf 100644
--- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h
+++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h
@@ -19,6 +19,7 @@
 
 #include <camera_device_session_hwl.h>
 
+#include <memory>
 #include <set>
 
 #include "EmulatedCameraDeviceHWLImpl.h"
@@ -203,7 +204,7 @@ class EmulatedCameraDeviceSessionHwlImpl : public CameraDeviceSessionHwl {
   bool has_raw_stream_ = false;
   std::unique_ptr<HalCameraMetadata> static_metadata_;
   std::vector<EmulatedPipeline> pipelines_;
-  std::unique_ptr<EmulatedRequestProcessor> request_processor_;
+  std::shared_ptr<EmulatedRequestProcessor> request_processor_;
   std::unique_ptr<StreamConfigurationMap> stream_configuration_map_;
   PhysicalStreamConfigurationMap physical_stream_configuration_map_;
   PhysicalStreamConfigurationMap physical_stream_configuration_map_max_resolution_;
diff --git a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h
index 1a7edfc..adedc21 100644
--- a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h
+++ b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h
@@ -32,6 +32,7 @@ struct EmulatedStream : public HalStream {
   size_t buffer_size;
   bool is_input;
   int32_t group_id;
+  int64_t use_case;
 };
 
 struct EmulatedPipeline {
diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp
index 8c7f24d..05f3263 100644
--- a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp
@@ -26,9 +26,17 @@
 #include <utils/Timers.h>
 #include <utils/Trace.h>
 
+#include <memory>
+
+#include "GrallocSensorBuffer.h"
+
 namespace android {
 
+using ::android::frameworks::sensorservice::V1_0::ISensorManager;
+using ::android::frameworks::sensorservice::V1_0::Result;
 using android::hardware::camera::common::V1_0::helper::HandleImporter;
+using ::android::hardware::sensors::V1_0::SensorInfo;
+using ::android::hardware::sensors::V1_0::SensorType;
 using google_camera_hal::ErrorCode;
 using google_camera_hal::HwlPipelineResult;
 using google_camera_hal::MessageType;
@@ -56,6 +64,12 @@ EmulatedRequestProcessor::~EmulatedRequestProcessor() {
     ALOGE("%s: Failed during sensor shutdown %s (%d)", __FUNCTION__,
           strerror(-ret), ret);
   }
+
+  if (sensor_event_queue_.get() != nullptr) {
+    sensor_event_queue_->disableSensor(sensor_handle_);
+    sensor_event_queue_.clear();
+    sensor_event_queue_ = nullptr;
+  }
 }
 
 status_t EmulatedRequestProcessor::ProcessPipelineRequests(
@@ -327,13 +341,14 @@ std::unique_ptr<SensorBuffer> EmulatedRequestProcessor::CreateSensorBuffer(
     uint32_t pipeline_id, HwlPipelineCallback callback,
     StreamBuffer stream_buffer, int32_t override_width,
     int32_t override_height) {
-  auto buffer = std::make_unique<SensorBuffer>(importer_);
+  auto buffer = std::make_unique<GrallocSensorBuffer>(importer_);
 
   auto stream = emulated_stream;
   // Make sure input stream formats are correctly mapped here
   if (stream.is_input) {
-    stream.override_format =
-        EmulatedSensor::OverrideFormat(stream.override_format);
+    stream.override_format = EmulatedSensor::OverrideFormat(
+        stream.override_format,
+        ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD);
   }
   if (override_width > 0 && override_height > 0) {
     buffer->width = override_width;
@@ -454,6 +469,13 @@ void EmulatedRequestProcessor::RequestProcessorLoop() {
           if (ret == OK) {
             auto result = request_state_->InitializeLogicalResult(pipeline_id,
                                                                   frame_number);
+            // The screen rotation will be the same for all logical and physical devices
+            uint32_t screen_rotation = screen_rotation_;
+            for (auto it = logical_settings->begin();
+                 it != logical_settings->end(); it++) {
+              it->second.screen_rotation = screen_rotation;
+            }
+
             sensor_->SetCurrentRequest(
                 std::move(logical_settings), std::move(result),
                 std::move(input_buffers), std::move(output_buffers));
@@ -510,4 +532,84 @@ status_t EmulatedRequestProcessor::GetDefaultRequest(
   return request_state_->GetDefaultRequest(type, default_settings);
 }
 
+Return<void> EmulatedRequestProcessor::SensorHandler::onEvent(const Event& e) {
+  auto processor = processor_.lock();
+  if (processor.get() == nullptr) {
+    return Void();
+  }
+
+  if (e.sensorType == SensorType::ACCELEROMETER) {
+    // Heuristic approach for deducing the screen
+    // rotation depending on the reported
+    // accelerometer readings. We switch
+    // the screen rotation when one of the
+    // x/y axis gets close enough to the earth
+    // acceleration.
+    const uint32_t earth_accel = 9;  // Switch threshold [m/s^2]
+    uint32_t x_accel = e.u.vec3.x;
+    uint32_t y_accel = e.u.vec3.y;
+    if (x_accel == earth_accel) {
+      processor->screen_rotation_ = 270;
+    } else if (x_accel == -earth_accel) {
+      processor->screen_rotation_ = 90;
+    } else if (y_accel == -earth_accel) {
+      processor->screen_rotation_ = 180;
+    } else {
+      processor->screen_rotation_ = 0;
+    }
+  } else {
+    ALOGE("%s: unexpected event received type: %d", __func__, e.sensorType);
+  }
+  return Void();
+}
+
+void EmulatedRequestProcessor::InitializeSensorQueue(
+    std::weak_ptr<EmulatedRequestProcessor> processor) {
+  if (sensor_event_queue_.get() != nullptr) {
+    return;
+  }
+
+  sp<ISensorManager> manager = ISensorManager::getService();
+  if (manager == nullptr) {
+    ALOGE("%s: Cannot get ISensorManager", __func__);
+  } else {
+    bool sensor_found = false;
+    manager->getSensorList([&](const auto& list, auto result) {
+      if (result != Result::OK) {
+        ALOGE("%s: Failed to retrieve sensor list!", __func__);
+      } else {
+        for (const SensorInfo& it : list) {
+          if (it.type == SensorType::ACCELEROMETER) {
+            sensor_found = true;
+            sensor_handle_ = it.sensorHandle;
+          }
+        }
+      }
+    });
+    if (sensor_found) {
+      manager->createEventQueue(
+          new SensorHandler(processor), [&](const auto& q, auto result) {
+            if (result != Result::OK) {
+              ALOGE("%s: Cannot create event queue", __func__);
+              return;
+            }
+            sensor_event_queue_ = q;
+          });
+
+      if (sensor_event_queue_.get() != nullptr) {
+        auto res = sensor_event_queue_->enableSensor(
+            sensor_handle_,
+            ns2us(EmulatedSensor::kSupportedFrameDurationRange[0]),
+            0 /*maxBatchReportLatencyUs*/);
+        if (res.isOk()) {
+        } else {
+          ALOGE("%s: Failed to enable sensor", __func__);
+        }
+      } else {
+        ALOGE("%s: Failed to create event queue", __func__);
+      }
+    }
+  }
+}
+
 }  // namespace android
diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h
index 4f47e89..f931e35 100644
--- a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h
+++ b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h
@@ -18,16 +18,26 @@
 #define EMULATOR_CAMERA_HAL_HWL_REQUEST_PROCESSOR_H
 
 #include <condition_variable>
+#include <memory>
 #include <mutex>
 #include <queue>
 #include <thread>
 
 #include "EmulatedLogicalRequestState.h"
 #include "EmulatedSensor.h"
+#include "HandleImporter.h"
+#include "android/frameworks/sensorservice/1.0/ISensorManager.h"
+#include "android/frameworks/sensorservice/1.0/types.h"
 #include "hwl_types.h"
 
 namespace android {
 
+using ::android::frameworks::sensorservice::V1_0::IEventQueue;
+using ::android::frameworks::sensorservice::V1_0::IEventQueueCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using android::hardware::camera::common::V1_0::helper::HandleImporter;
+using ::android::hardware::sensors::V1_0::Event;
 using google_camera_hal::HalCameraMetadata;
 using google_camera_hal::HwlPipelineRequest;
 using google_camera_hal::HwlSessionCallback;
@@ -62,10 +72,28 @@ class EmulatedRequestProcessor {
 
   status_t Initialize(std::unique_ptr<HalCameraMetadata> static_meta,
                       PhysicalDeviceMapPtr physical_devices);
+  void InitializeSensorQueue(std::weak_ptr<EmulatedRequestProcessor> processor);
 
   void SetSessionCallback(const HwlSessionCallback& hwl_session_callback);
 
  private:
+  class SensorHandler : public IEventQueueCallback {
+   public:
+    SensorHandler(std::weak_ptr<EmulatedRequestProcessor> processor)
+        : processor_(processor) {
+    }
+
+    // IEventQueueCallback interface
+    Return<void> onEvent(const Event& e) override;
+
+   private:
+    std::weak_ptr<EmulatedRequestProcessor> processor_;
+  };
+
+  int32_t sensor_handle_;
+  sp<IEventQueue> sensor_event_queue_;
+  std::atomic_uint32_t screen_rotation_;
+
   void RequestProcessorLoop();
 
   std::thread request_thread_;
diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp
index e7c62f9..f5f1f2b 100644
--- a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp
@@ -41,7 +41,9 @@ const std::set<uint8_t> EmulatedRequestState::kSupportedCapabilites = {
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING,
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA,
     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING,
-    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR};
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR,
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT,
+    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE};
 
 const std::set<uint8_t> EmulatedRequestState::kSupportedHWLevels = {
     ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
@@ -49,6 +51,14 @@ const std::set<uint8_t> EmulatedRequestState::kSupportedHWLevels = {
     ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3,
 };
 
+const std::vector<int64_t> EmulatedRequestState::kSupportedUseCases = {
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW,
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE,
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD,
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL,
+    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL};
+
 template <typename T>
 T GetClosestValue(T val, T min, T max) {
   if ((min > max) || ((val >= min) && (val <= max))) {
@@ -2741,8 +2751,12 @@ status_t EmulatedRequestState::InitializeReprocessDefaults() {
           config_map.GetValidOutputFormatsForInput(input_format);
       for (const auto& output_format : output_formats) {
         if (!EmulatedSensor::IsReprocessPathSupported(
-                EmulatedSensor::OverrideFormat(input_format),
-                EmulatedSensor::OverrideFormat(output_format))) {
+                EmulatedSensor::OverrideFormat(
+                    input_format,
+                    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
+                EmulatedSensor::OverrideFormat(
+                    output_format,
+                    ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD))) {
           ALOGE(
               "%s: Input format: 0x%x to output format: 0x%x reprocess is"
               " currently not supported!",
@@ -2832,12 +2846,31 @@ status_t EmulatedRequestState::InitializeRequestDefaults() {
       ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
   is_raw_capable_ =
       SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW);
+  supports_stream_use_case_ =
+      SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE);
 
   if (supports_manual_sensor_) {
     auto templateIdx = static_cast<size_t>(RequestTemplate::kManual);
     default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
   }
 
+  if (supports_stream_use_case_) {
+    ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES,
+                                &entry);
+    if (ret != OK) {
+      ALOGE("%s: No available stream use cases!", __FUNCTION__);
+      return BAD_VALUE;
+    }
+    for (int64_t useCase : kSupportedUseCases) {
+      if (std::find(entry.data.i64, entry.data.i64 + entry.count, useCase) ==
+          entry.data.i64 + entry.count) {
+        ALOGE("%s: Mandatory stream use case %" PRId64 " not found!",
+              __FUNCTION__, useCase);
+        return BAD_VALUE;
+      }
+    }
+  }
+
   for (size_t templateIdx = 0; templateIdx < kTemplateCount; templateIdx++) {
     switch (static_cast<RequestTemplate>(templateIdx)) {
       case RequestTemplate::kPreview:
diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestState.h b/devices/EmulatedCamera/hwl/EmulatedRequestState.h
index 1987bfa..8bf5408 100644
--- a/devices/EmulatedCamera/hwl/EmulatedRequestState.h
+++ b/devices/EmulatedCamera/hwl/EmulatedRequestState.h
@@ -96,6 +96,7 @@ class EmulatedRequestState {
   static const std::set<uint8_t> kSupportedCapabilites;
   static const std::set<uint8_t> kSupportedHWLevels;
   std::unique_ptr<HalCameraMetadata> static_metadata_;
+  static const std::vector<int64_t> kSupportedUseCases;
 
   // android.blacklevel.*
   uint8_t black_level_lock_ = ANDROID_BLACK_LEVEL_LOCK_ON;
@@ -128,6 +129,7 @@ class EmulatedRequestState {
   bool supports_private_reprocessing_ = false;
   bool supports_yuv_reprocessing_ = false;
   bool supports_remosaic_reprocessing_ = false;
+  bool supports_stream_use_case_ = false;
 
   // android.control.*
   struct SceneOverride {
diff --git a/devices/EmulatedCamera/hwl/EmulatedScene.cpp b/devices/EmulatedCamera/hwl/EmulatedScene.cpp
index 965b3b5..800eacb 100644
--- a/devices/EmulatedCamera/hwl/EmulatedScene.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedScene.cpp
@@ -29,11 +29,6 @@
 
 namespace android {
 
-using ::android::frameworks::sensorservice::V1_0::ISensorManager;
-using ::android::frameworks::sensorservice::V1_0::Result;
-using ::android::hardware::sensors::V1_0::SensorInfo;
-using ::android::hardware::sensors::V1_0::SensorType;
-
 // Define single-letter shortcuts for scene definition, for directly indexing
 // mCurrentColors
 #define G (EmulatedScene::GRASS * EmulatedScene::NUM_CHANNELS)
@@ -89,8 +84,7 @@ const uint8_t EmulatedScene::kScene[EmulatedScene::kSceneWidth *
 EmulatedScene::EmulatedScene(int sensor_width_px, int sensor_height_px,
                              float sensor_sensitivity, int sensor_orientation,
                              bool is_front_facing)
-    : sensor_handle_(-1),
-      screen_rotation_(0),
+    : screen_rotation_(0),
       current_scene_(scene_rot0_),
       sensor_orientation_(sensor_orientation),
       is_front_facing_(is_front_facing),
@@ -115,11 +109,6 @@ EmulatedScene::EmulatedScene(int sensor_width_px, int sensor_height_px,
 }
 
 EmulatedScene::~EmulatedScene() {
-  if (sensor_event_queue_.get() != nullptr) {
-    sensor_event_queue_->disableSensor(sensor_handle_);
-    sensor_event_queue_.clear();
-    sensor_event_queue_ = nullptr;
-  }
 }
 
 void EmulatedScene::Initialize(int sensor_width_px, int sensor_height_px,
@@ -140,37 +129,6 @@ void EmulatedScene::Initialize(int sensor_width_px, int sensor_height_px,
 
 }
 
-Return<void> EmulatedScene::SensorHandler::onEvent(const Event& e) {
-  auto scene = scene_.promote();
-  if (scene.get() == nullptr) {
-    return Void();
-  }
-
-  if (e.sensorType == SensorType::ACCELEROMETER) {
-    // Heuristic approach for deducing the screen
-    // rotation depending on the reported
-    // accelerometer readings. We switch
-    // the screen rotation when one of the
-    // x/y axis gets close enough to the earth
-    // acceleration.
-    const uint32_t earth_accel = 9; // Switch threshold [m/s^2]
-    uint32_t x_accel = e.u.vec3.x;
-    uint32_t y_accel = e.u.vec3.y;
-    if (x_accel == earth_accel) {
-      scene->screen_rotation_ = 270;
-    } else if (x_accel == -earth_accel) {
-      scene->screen_rotation_ = 90;
-    } else if (y_accel == -earth_accel) {
-      scene->screen_rotation_ = 180;
-    } else {
-      scene->screen_rotation_ = 0;
-    }
-  } else {
-    ALOGE("%s: unexpected event received type: %d", __func__, e.sensorType);
-  }
-  return Void();
-}
-
 void EmulatedScene::SetColorFilterXYZ(float rX, float rY, float rZ, float grX,
                                       float grY, float grZ, float gbX, float gbY,
                                       float gbZ, float bX, float bY, float bZ) {
@@ -197,6 +155,10 @@ int EmulatedScene::GetHour() const {
   return hour_;
 }
 
+void EmulatedScene::SetScreenRotation(uint32_t screen_rotation) {
+  screen_rotation_ = screen_rotation;
+}
+
 void EmulatedScene::SetExposureDuration(float seconds) {
   exposure_duration_ = seconds;
 }
@@ -389,24 +351,21 @@ void EmulatedScene::CalculateScene(nsecs_t time, int32_t handshake_divider) {
     handshake_y_ /= handshake_divider;
   }
 
-  if (sensor_event_queue_.get() != nullptr) {
-    int32_t sensor_orientation = is_front_facing_ ? -sensor_orientation_ : sensor_orientation_;
-    int32_t scene_rotation = ((screen_rotation_ + 360) + sensor_orientation) % 360;
-    switch (scene_rotation) {
-      case 90:
-        current_scene_ = scene_rot90_;
-        break;
-      case 180:
-        current_scene_ = scene_rot180_;
-        break;
-      case 270:
-        current_scene_ = scene_rot270_;
-        break;
-      default:
-        current_scene_ = scene_rot0_;
-    }
-  } else {
-    current_scene_ = scene_rot0_;
+  int32_t sensor_orientation =
+      is_front_facing_ ? -sensor_orientation_ : sensor_orientation_;
+  int32_t scene_rotation = ((screen_rotation_ + 360) + sensor_orientation) % 360;
+  switch (scene_rotation) {
+    case 90:
+      current_scene_ = scene_rot90_;
+      break;
+    case 180:
+      current_scene_ = scene_rot180_;
+      break;
+    case 270:
+      current_scene_ = scene_rot270_;
+      break;
+    default:
+      current_scene_ = scene_rot0_;
   }
 
   // Set starting pixel
@@ -446,52 +405,6 @@ void EmulatedScene::InitiliazeSceneRotation(bool clock_wise) {
   }
 }
 
-void EmulatedScene::InitializeSensorQueue() {
-  if (sensor_event_queue_.get() != nullptr) {
-    return;
-  }
-
-  sp<ISensorManager> manager = ISensorManager::getService();
-  if (manager == nullptr) {
-    ALOGE("%s: Cannot get ISensorManager", __func__);
-  } else {
-    bool sensor_found = false;
-    manager->getSensorList(
-        [&] (const auto& list, auto result) {
-        if (result != Result::OK) {
-          ALOGE("%s: Failed to retrieve sensor list!", __func__);
-        } else {
-          for (const SensorInfo& it : list) {
-            if (it.type == SensorType::ACCELEROMETER) {
-              sensor_found = true;
-              sensor_handle_ = it.sensorHandle;
-            }
-          }
-        }});
-    if (sensor_found) {
-      manager->createEventQueue(
-          new SensorHandler(this), [&](const auto& q, auto result) {
-            if (result != Result::OK) {
-              ALOGE("%s: Cannot create event queue", __func__);
-              return;
-            }
-            sensor_event_queue_ = q;
-          });
-
-      if (sensor_event_queue_.get() != nullptr) {
-        auto res = sensor_event_queue_->enableSensor(sensor_handle_,
-            ns2us(EmulatedSensor::kSupportedFrameDurationRange[0]), 0/*maxBatchReportLatencyUs*/);
-        if (res.isOk()) {
-        } else {
-          ALOGE("%s: Failed to enable sensor", __func__);
-        }
-      } else {
-        ALOGE("%s: Failed to create event queue", __func__);
-      }
-    }
-  }
-}
-
 void EmulatedScene::SetReadoutPixel(int x, int y) {
   current_x_ = x;
   current_y_ = y;
diff --git a/devices/EmulatedCamera/hwl/EmulatedScene.h b/devices/EmulatedCamera/hwl/EmulatedScene.h
index 0334a58..0672422 100644
--- a/devices/EmulatedCamera/hwl/EmulatedScene.h
+++ b/devices/EmulatedCamera/hwl/EmulatedScene.h
@@ -26,27 +26,17 @@
 #ifndef HW_EMULATOR_CAMERA2_SCENE_H
 #define HW_EMULATOR_CAMERA2_SCENE_H
 
-#include "android/frameworks/sensorservice/1.0/ISensorManager.h"
-#include "android/frameworks/sensorservice/1.0/types.h"
 #include "utils/Timers.h"
 
 namespace android {
 
-using ::android::frameworks::sensorservice::V1_0::IEventQueue;
-using ::android::frameworks::sensorservice::V1_0::IEventQueueCallback;
-using ::android::hardware::sensors::V1_0::Event;
-using ::android::hardware::Return;
-using ::android::hardware::Void;
-
-class EmulatedScene : public RefBase {
+class EmulatedScene {
  public:
   EmulatedScene(int sensor_width_px, int sensor_height_px,
                 float sensor_sensitivity, int sensor_orientation,
                 bool is_front_facing);
   ~EmulatedScene();
 
-  void InitializeSensorQueue();
-
   void Initialize(int sensor_width_px, int sensor_height_px,
                   float sensor_sensitivity);
 
@@ -65,6 +55,8 @@ class EmulatedScene : public RefBase {
   // Get current hour
   int GetHour() const;
 
+  void SetScreenRotation(uint32_t screen_rotation);
+
   // Set the duration of exposure for determining luminous exposure.
   // Must be called before calculateScene
   void SetExposureDuration(float seconds);
@@ -99,27 +91,13 @@ class EmulatedScene : public RefBase {
   static const int kSceneHeight = 20;
 
  private:
-  class SensorHandler : public IEventQueueCallback {
-   public:
-    SensorHandler(wp<EmulatedScene> scene) : scene_(scene) {
-    }
-
-    // IEventQueueCallback interface
-    Return<void> onEvent(const Event& e) override;
-
-   private:
-    wp<EmulatedScene> scene_;
-  };
-
   void InitiliazeSceneRotation(bool clock_wise);
 
-  int32_t sensor_handle_;
-  sp<IEventQueue> sensor_event_queue_;
-  std::atomic_uint32_t screen_rotation_;
   uint8_t scene_rot0_[kSceneWidth*kSceneHeight];
   uint8_t scene_rot90_[kSceneWidth*kSceneHeight];
   uint8_t scene_rot180_[kSceneWidth*kSceneHeight];
   uint8_t scene_rot270_[kSceneWidth*kSceneHeight];
+  uint32_t screen_rotation_;
   uint8_t *current_scene_;
   int32_t sensor_orientation_;
   bool is_front_facing_;
diff --git a/devices/EmulatedCamera/hwl/EmulatedSensor.cpp b/devices/EmulatedCamera/hwl/EmulatedSensor.cpp
index 6b6d678..7d93ded 100644
--- a/devices/EmulatedCamera/hwl/EmulatedSensor.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedSensor.cpp
@@ -16,6 +16,7 @@
 
 //#define LOG_NDEBUG 0
 //#define LOG_NNDEBUG 0
+#include "system/graphics-base-v1.1.h"
 #define LOG_TAG "EmulatedSensor"
 #define ATRACE_TAG ATRACE_TAG_CAMERA
 
@@ -25,11 +26,11 @@
 #define ALOGVV(...) ((void)0)
 #endif
 
-#include "EmulatedSensor.h"
-
+#include <android/hardware/graphics/common/1.2/types.h>
 #include <cutils/properties.h>
 #include <inttypes.h>
 #include <libyuv.h>
+#include <memory.h>
 #include <system/camera_metadata.h>
 #include <utils/Log.h>
 #include <utils/Trace.h>
@@ -37,15 +38,19 @@
 #include <cmath>
 #include <cstdlib>
 
+#include "EmulatedSensor.h"
 #include "utils/ExifUtils.h"
 #include "utils/HWLUtils.h"
 
 namespace android {
 
+using android::google_camera_hal::ErrorCode;
 using google_camera_hal::HalCameraMetadata;
 using google_camera_hal::MessageType;
 using google_camera_hal::NotifyMessage;
 
+using android::hardware::graphics::common::V1_2::Dataspace;
+
 const uint32_t EmulatedSensor::kRegularSceneHandshake = 1; // Scene handshake divider
 const uint32_t EmulatedSensor::kReducedSceneHandshake = 2; // Scene handshake divider
 
@@ -161,6 +166,17 @@ bool EmulatedSensor::AreCharacteristicsSupported(
     return false;
   }
 
+  if (characteristics.is_10bit_dynamic_range_capable) {
+    // We support only HLG10 at the moment
+    const auto& hlg10_entry = characteristics.dynamic_range_profiles.find(
+        ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10);
+    if ((characteristics.dynamic_range_profiles.size() != 1) ||
+        (hlg10_entry == characteristics.dynamic_range_profiles.end())) {
+      ALOGE("%s: Only support for HLG10 is available!", __FUNCTION__);
+      return false;
+    }
+  }
+
   if ((characteristics.exposure_time_range[0] >=
        characteristics.exposure_time_range[1]) ||
       ((characteristics.exposure_time_range[0] < kSupportedExposureTimeRange[0]) ||
@@ -361,6 +377,45 @@ bool EmulatedSensor::IsStreamCombinationSupported(
         }
       }
 
+      if (stream.dynamic_profile !=
+          ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD) {
+        const SensorCharacteristics& sensor_char =
+            stream.is_physical_camera_stream
+                ? sensor_chars.at(stream.physical_camera_id)
+                : sensor_chars.at(logical_id);
+        if (!sensor_char.is_10bit_dynamic_range_capable) {
+          ALOGE("%s: 10-bit dynamic range output not supported on this device!",
+                __FUNCTION__);
+          return false;
+        }
+
+        if ((stream.format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) &&
+            (static_cast<android_pixel_format_v1_1_t>(stream.format) !=
+             HAL_PIXEL_FORMAT_YCBCR_P010)) {
+          ALOGE(
+              "%s: 10-bit dynamic range profile 0x%x not supported on a non "
+              "10-bit output stream"
+              " pixel format 0x%x",
+              __FUNCTION__, stream.dynamic_profile, stream.format);
+          return false;
+        }
+
+        if ((static_cast<android_pixel_format_v1_1_t>(stream.format) ==
+             HAL_PIXEL_FORMAT_YCBCR_P010) &&
+            ((stream.data_space !=
+              static_cast<android_dataspace_t>(Dataspace::BT2020_ITU_HLG)) &&
+             (stream.data_space !=
+              static_cast<android_dataspace_t>(Dataspace::BT2020_HLG)) &&
+             (stream.data_space !=
+              static_cast<android_dataspace_t>(Dataspace::UNKNOWN)))) {
+          ALOGE(
+              "%s: Unsupported stream data space 0x%x for 10-bit YUV "
+              "output",
+              __FUNCTION__, stream.data_space);
+          return false;
+        }
+      }
+
       switch (stream.format) {
         case HAL_PIXEL_FORMAT_BLOB:
           if ((stream.data_space != HAL_DATASPACE_V0_JFIF) &&
@@ -429,6 +484,35 @@ bool EmulatedSensor::IsStreamCombinationSupported(
         return false;
       }
     }
+
+    if (!sensor_chars.at(logical_id).support_stream_use_case) {
+      if (stream.use_case != ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT) {
+        ALOGE("%s: Camera device doesn't support non-default stream use case!",
+              __FUNCTION__);
+        return false;
+      }
+    } else if (stream.use_case >
+               ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL) {
+      ALOGE("%s: Stream with use case %d is not supported!", __FUNCTION__,
+            stream.use_case);
+      return false;
+    } else if (stream.use_case !=
+               ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT) {
+      if (stream.use_case ==
+              ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE) {
+        if (stream.format != HAL_PIXEL_FORMAT_YCBCR_420_888 &&
+            stream.format != HAL_PIXEL_FORMAT_BLOB) {
+          ALOGE("%s: Stream with use case %d isn't compatible with format %d",
+              __FUNCTION__, stream.use_case, stream.format);
+          return false;
+        }
+      } else if (stream.format != HAL_PIXEL_FORMAT_YCBCR_420_888 &&
+                 stream.format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
+        ALOGE("%s: Stream with use case %d isn't compatible with format %d",
+              __FUNCTION__, stream.use_case, stream.format);
+        return false;
+      }
+    }
   }
 
   for (const auto& raw_count : raw_stream_count) {
@@ -503,11 +587,10 @@ status_t EmulatedSensor::StartUp(
   }
 
   logical_camera_id_ = logical_camera_id;
-  scene_ = new EmulatedScene(
+  scene_ = std::make_unique<EmulatedScene>(
       device_chars->second.full_res_width, device_chars->second.full_res_height,
       kElectronsPerLuxSecond, device_chars->second.orientation,
       device_chars->second.is_front_facing);
-  scene_->InitializeSensorQueue();
   jpeg_compressor_ = std::make_unique<JpegCompressor>();
 
   auto res = run(LOG_TAG, ANDROID_PRIORITY_URGENT_DISPLAY);
@@ -628,9 +711,11 @@ bool EmulatedSensor::threadLoop() {
   }
 
   auto frame_duration = EmulatedSensor::kSupportedFrameDurationRange[0];
+  auto exposure_time = EmulatedSensor::kSupportedExposureTimeRange[0];
   // Frame duration must always be the same among all physical devices
   if ((settings.get() != nullptr) && (!settings->empty())) {
     frame_duration = settings->begin()->second.frame_duration;
+    exposure_time = settings->begin()->second.exposure_time;
   }
 
   nsecs_t start_real_time = systemTime();
@@ -642,6 +727,7 @@ bool EmulatedSensor::threadLoop() {
    * Stage 2: Capture new image
    */
   next_capture_time_ = frame_end_real_time;
+  next_readout_time_ = frame_end_real_time + exposure_time;
 
   sensor_binning_factor_info_.clear();
 
@@ -660,6 +746,14 @@ bool EmulatedSensor::threadLoop() {
         ALOGW("%s: Reprocess timestamp absent!", __FUNCTION__);
       }
 
+      ret = next_result->result_metadata->Get(ANDROID_SENSOR_EXPOSURE_TIME,
+                                              &entry);
+      if ((ret == OK) && (entry.count == 1)) {
+        next_readout_time_ = next_capture_time_ + entry.data.i64[0];
+      } else {
+        next_readout_time_ = next_capture_time_;
+      }
+
       reprocess_request = true;
   }
 
@@ -670,7 +764,9 @@ bool EmulatedSensor::threadLoop() {
           .type = MessageType::kShutter,
           .message.shutter = {
               .frame_number = next_buffers->at(0)->frame_number,
-              .timestamp_ns = static_cast<uint64_t>(next_capture_time_)}};
+              .timestamp_ns = static_cast<uint64_t>(next_capture_time_),
+              .readout_timestamp_ns =
+                  static_cast<uint64_t>(next_readout_time_)}};
       callback.notify(next_result->pipeline_id, msg);
     }
     auto b = next_buffers->begin();
@@ -718,10 +814,15 @@ bool EmulatedSensor::threadLoop() {
       scene_->SetTestPattern(device_settings->second.test_pattern_mode ==
                              ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR);
       scene_->SetTestPatternData(device_settings->second.test_pattern_data);
+      scene_->SetScreenRotation(device_settings->second.screen_rotation);
 
       uint32_t handshake_divider =
-        (device_settings->second.video_stab == ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON) ?
-        kReducedSceneHandshake : kRegularSceneHandshake;
+          (device_settings->second.video_stab ==
+           ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON) ||
+                  (device_settings->second.video_stab ==
+                   ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION)
+              ? kReducedSceneHandshake
+              : kRegularSceneHandshake;
       scene_->CalculateScene(next_capture_time_, handshake_divider);
 
       (*b)->stream_buffer.status = BufferStatus::kOk;
@@ -1010,9 +1111,6 @@ bool EmulatedSensor::threadLoop() {
       ret = nanosleep(&t, &t);
     } while (ret != 0);
   }
-  nsecs_t end_real_time __unused = systemTime();
-  ALOGVV("Frame cycle took %" PRIu64 "  ms, target %" PRIu64 " ms",
-         ns2ms(end_real_time - start_real_time), ns2ms(frame_duration));
 
   ReturnResults(callback, std::move(settings), std::move(next_result),
                 reprocess_request);
diff --git a/devices/EmulatedCamera/hwl/EmulatedSensor.h b/devices/EmulatedCamera/hwl/EmulatedSensor.h
index 3141b8b..8c63ae4 100644
--- a/devices/EmulatedCamera/hwl/EmulatedSensor.h
+++ b/devices/EmulatedCamera/hwl/EmulatedSensor.h
@@ -77,11 +77,11 @@
 
 #include <hwl_types.h>
 
+#include <algorithm>
 #include <functional>
 
 #include "Base.h"
 #include "EmulatedScene.h"
-#include "HandleImporter.h"
 #include "JpegCompressor.h"
 #include "utils/Mutex.h"
 #include "utils/StreamConfigurationMap.h"
@@ -90,7 +90,6 @@
 
 namespace android {
 
-using android::hardware::camera::common::V1_0::helper::HandleImporter;
 using google_camera_hal::HwlPipelineCallback;
 using google_camera_hal::HwlPipelineResult;
 using google_camera_hal::StreamConfiguration;
@@ -113,6 +112,12 @@ struct ColorFilterXYZ {
   float bZ = 1.0570f;
 };
 
+typedef std::unordered_map<
+    camera_metadata_enum_android_request_available_dynamic_range_profiles_map,
+    std::unordered_set<
+        camera_metadata_enum_android_request_available_dynamic_range_profiles_map>>
+    ProfileMap;
+
 struct SensorCharacteristics {
   size_t width = 0;
   size_t height = 0;
@@ -137,6 +142,9 @@ struct SensorCharacteristics {
   uint32_t orientation = 0;
   bool is_front_facing = false;
   bool quad_bayer_sensor = false;
+  bool is_10bit_dynamic_range_capable = false;
+  ProfileMap dynamic_range_profiles;
+  bool support_stream_use_case = false;
 };
 
 // Maps logical/physical camera ids to sensor characteristics
@@ -147,9 +155,25 @@ class EmulatedSensor : private Thread, public virtual RefBase {
   EmulatedSensor();
   ~EmulatedSensor();
 
-  static android_pixel_format_t OverrideFormat(android_pixel_format_t format) {
-    if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
-      return HAL_PIXEL_FORMAT_YCBCR_420_888;
+  static android_pixel_format_t OverrideFormat(
+      android_pixel_format_t format,
+      camera_metadata_enum_android_request_available_dynamic_range_profiles_map
+          profile) {
+    switch (profile) {
+      case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD:
+        if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
+          return HAL_PIXEL_FORMAT_YCBCR_420_888;
+        }
+        break;
+      case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10:
+        if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
+          return static_cast<android_pixel_format_t>(
+              HAL_PIXEL_FORMAT_YCBCR_P010);
+        }
+        break;
+      default:
+        ALOGE("%s: Unsupported dynamic range profile 0x%x", __FUNCTION__,
+              profile);
     }
 
     return format;
@@ -216,6 +240,7 @@ class EmulatedSensor : private Thread, public virtual RefBase {
     uint8_t sensor_pixel_mode = ANDROID_SENSOR_PIXEL_MODE_DEFAULT;
     uint8_t test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
     uint32_t test_pattern_data[4] = {0, 0, 0, 0};
+    uint32_t screen_rotation = 0;
   };
 
   // Maps physical and logical camera ids to individual device settings
@@ -313,6 +338,7 @@ class EmulatedSensor : private Thread, public virtual RefBase {
   bool threadLoop() override;
 
   nsecs_t next_capture_time_;
+  nsecs_t next_readout_time_;
 
   struct SensorBinningFactorInfo {
     bool has_raw_stream = false;
@@ -323,7 +349,7 @@ class EmulatedSensor : private Thread, public virtual RefBase {
 
   std::map<uint32_t, SensorBinningFactorInfo> sensor_binning_factor_info_;
 
-  sp<EmulatedScene> scene_;
+  std::unique_ptr<EmulatedScene> scene_;
 
   static EmulatedScene::ColorChannels GetQuadBayerColor(uint32_t x, uint32_t y);
 
diff --git a/devices/EmulatedCamera/hwl/EmulatedTorchState.cpp b/devices/EmulatedCamera/hwl/EmulatedTorchState.cpp
index 207a40c..edb6311 100644
--- a/devices/EmulatedCamera/hwl/EmulatedTorchState.cpp
+++ b/devices/EmulatedCamera/hwl/EmulatedTorchState.cpp
@@ -32,9 +32,36 @@ status_t EmulatedTorchState::SetTorchMode(TorchMode mode) {
     return UNKNOWN_ERROR;
   }
 
+  torch_status_ = (mode == TorchMode::kOn) ? TorchModeStatus::kAvailableOn : TorchModeStatus::kAvailableOff;
+  if (mode == TorchMode::kOff && support_torch_strength_control_) {
+    new_torch_strength_level_ = default_level_;
+    ALOGV("%s: Turning torch OFF so reset the torch strength to default level:%d",
+          __FUNCTION__, default_level_);
+  }
+
   torch_cb_(camera_id_, (mode == TorchMode::kOn)
                             ? TorchModeStatus::kAvailableOn
                             : TorchModeStatus::kAvailableOff);
+  return OK;
+}
+
+status_t EmulatedTorchState::TurnOnTorchWithStrengthLevel(int32_t torch_strength) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (camera_open_) {
+    ALOGE("%s: Camera device open, torch cannot be controlled using this API!",
+          __FUNCTION__);
+    return UNKNOWN_ERROR;
+  }
+  new_torch_strength_level_ = torch_strength;
+  // If the torch mode is OFF and device is available, torch will be turned ON.
+  // torch_strength value should be greater than 1.
+  if (torch_status_ != TorchModeStatus::kAvailableOn && torch_strength > 1) {
+    torch_status_ = TorchModeStatus::kAvailableOn;
+    ALOGV("Changed the torch status to: %d", torch_status_);
+    torch_cb_(camera_id_, TorchModeStatus::kAvailableOn);
+  }
+
+  ALOGV("%s: Torch strength level successfully set to %d", __FUNCTION__, torch_strength);
 
   return OK;
 }
@@ -51,4 +78,20 @@ void EmulatedTorchState::ReleaseFlashHw() {
   torch_cb_(camera_id_, TorchModeStatus::kAvailableOff);
 }
 
+int32_t EmulatedTorchState::GetTorchStrengthLevel() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return new_torch_strength_level_;
+}
+
+void EmulatedTorchState::InitializeTorchDefaultLevel(int32_t default_level) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  default_level_ = default_level;
+}
+
+void EmulatedTorchState::InitializeSupportTorchStrengthLevel(bool is_torch_strength_control_supported) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  support_torch_strength_control_ = is_torch_strength_control_supported;
+}
+
+
 }  // namespace android
diff --git a/devices/EmulatedCamera/hwl/EmulatedTorchState.h b/devices/EmulatedCamera/hwl/EmulatedTorchState.h
index de69eab..126e16b 100644
--- a/devices/EmulatedCamera/hwl/EmulatedTorchState.h
+++ b/devices/EmulatedCamera/hwl/EmulatedTorchState.h
@@ -26,6 +26,7 @@ namespace android {
 
 using android::google_camera_hal::HwlTorchModeStatusChangeFunc;
 using android::google_camera_hal::TorchMode;
+using android::google_camera_hal::TorchModeStatus;
 
 class EmulatedTorchState {
  public:
@@ -34,8 +35,13 @@ class EmulatedTorchState {
   }
 
   status_t SetTorchMode(TorchMode mode);
+  status_t TurnOnTorchWithStrengthLevel(int32_t torch_strength);
+
   void AcquireFlashHw();
   void ReleaseFlashHw();
+  int32_t GetTorchStrengthLevel();
+  void InitializeTorchDefaultLevel(int32_t default_level);
+  void InitializeSupportTorchStrengthLevel(bool is_torch_strength_control_supported);
 
  private:
   std::mutex mutex_;
@@ -43,6 +49,10 @@ class EmulatedTorchState {
   uint32_t camera_id_;
   HwlTorchModeStatusChangeFunc torch_cb_;
   bool camera_open_ = false;
+  TorchModeStatus torch_status_;
+  int32_t new_torch_strength_level_ = 0;
+  bool support_torch_strength_control_ = false;
+  int32_t default_level_ = 0;
 
   EmulatedTorchState(const EmulatedTorchState&) = delete;
   EmulatedTorchState& operator=(const EmulatedTorchState&) = delete;
diff --git a/devices/EmulatedCamera/hwl/GrallocSensorBuffer.cpp b/devices/EmulatedCamera/hwl/GrallocSensorBuffer.cpp
new file mode 100644
index 0000000..173d4fc
--- /dev/null
+++ b/devices/EmulatedCamera/hwl/GrallocSensorBuffer.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GrallocSensorBuffer.h"
+
+namespace android {
+
+GrallocSensorBuffer::~GrallocSensorBuffer() {
+  if (stream_buffer.buffer != nullptr) {
+    importer_->unlock(stream_buffer.buffer);
+  }
+
+  if (acquire_fence_fd >= 0) {
+    importer_->closeFence(acquire_fence_fd);
+  }
+
+  if ((stream_buffer.status != BufferStatus::kOk) &&
+      (callback.notify != nullptr) && (!is_failed_request)) {
+    NotifyMessage msg = {
+        .type = MessageType::kError,
+        .message.error = {.frame_number = frame_number,
+                          .error_stream_id = stream_buffer.stream_id,
+                          .error_code = ErrorCode::kErrorBuffer}};
+    callback.notify(pipeline_id, msg);
+  }
+
+  if (callback.process_pipeline_result != nullptr) {
+    auto result = std::make_unique<HwlPipelineResult>();
+    result->camera_id = camera_id;
+    result->pipeline_id = pipeline_id;
+    result->frame_number = frame_number;
+    result->partial_result = 0;
+
+    stream_buffer.acquire_fence = stream_buffer.release_fence = nullptr;
+    if (is_input) {
+      result->input_buffers.push_back(stream_buffer);
+    } else {
+      result->output_buffers.push_back(stream_buffer);
+    }
+    callback.process_pipeline_result(std::move(result));
+  }
+}
+
+}  // namespace android
diff --git a/devices/EmulatedCamera/hwl/GrallocSensorBuffer.h b/devices/EmulatedCamera/hwl/GrallocSensorBuffer.h
new file mode 100644
index 0000000..3fd9726
--- /dev/null
+++ b/devices/EmulatedCamera/hwl/GrallocSensorBuffer.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HW_EMULATOR_GRALLOC_SENSOR_BUFFER_H
+#define HW_EMULATOR_GRALLOC_SENSOR_BUFFER_H
+
+#include <log/log.h>
+
+#include <memory>
+
+#include "Base.h"
+#include "HandleImporter.h"
+
+namespace android {
+
+using android::google_camera_hal::BufferStatus;
+using android::google_camera_hal::ErrorCode;
+using android::google_camera_hal::HwlPipelineResult;
+using android::google_camera_hal::MessageType;
+using android::google_camera_hal::NotifyMessage;
+using android::hardware::camera::common::V1_0::helper::HandleImporter;
+
+class GrallocSensorBuffer : public SensorBuffer {
+ public:
+  GrallocSensorBuffer(std::shared_ptr<HandleImporter> handle_importer)
+      : importer_(handle_importer) {
+  }
+
+  GrallocSensorBuffer(const GrallocSensorBuffer&) = delete;
+  GrallocSensorBuffer& operator=(const GrallocSensorBuffer&) = delete;
+
+  virtual ~GrallocSensorBuffer() override;
+
+ private:
+  std::shared_ptr<HandleImporter> importer_;
+};
+
+}  // namespace android
+
+#endif
diff --git a/devices/EmulatedCamera/hwl/JpegCompressor.cpp b/devices/EmulatedCamera/hwl/JpegCompressor.cpp
index 57530ad..582c92f 100644
--- a/devices/EmulatedCamera/hwl/JpegCompressor.cpp
+++ b/devices/EmulatedCamera/hwl/JpegCompressor.cpp
@@ -19,14 +19,16 @@
 
 #include "JpegCompressor.h"
 
+#include <camera_blob.h>
 #include <cutils/properties.h>
-#include <hardware/camera3.h>
 #include <libyuv.h>
 #include <utils/Log.h>
 #include <utils/Trace.h>
 
 namespace android {
 
+using google_camera_hal::CameraBlob;
+using google_camera_hal::CameraBlobId;
 using google_camera_hal::ErrorCode;
 using google_camera_hal::MessageType;
 using google_camera_hal::NotifyMessage;
@@ -204,13 +206,12 @@ void JpegCompressor::CompressYUV420(std::unique_ptr<JpegYUV420Job> job) {
   }
 
   auto jpeg_header_offset =
-      job->output->plane.img.buffer_size - sizeof(struct camera3_jpeg_blob);
+      job->output->plane.img.buffer_size - sizeof(struct CameraBlob);
   if (jpeg_header_offset > encoded_size) {
-    struct camera3_jpeg_blob* blob =
-        reinterpret_cast<struct camera3_jpeg_blob*>(job->output->plane.img.img +
-                                                    jpeg_header_offset);
-    blob->jpeg_blob_id = CAMERA3_JPEG_BLOB_ID;
-    blob->jpeg_size = encoded_size;
+    struct CameraBlob* blob = reinterpret_cast<struct CameraBlob*>(
+        job->output->plane.img.img + jpeg_header_offset);
+    blob->blob_id = CameraBlobId::JPEG;
+    blob->blob_size = encoded_size;
   } else {
     ALOGW("%s: No space for jpeg header at offset: %u and jpeg size: %u",
           __FUNCTION__, static_cast<unsigned>(jpeg_header_offset),
@@ -260,7 +261,7 @@ size_t JpegCompressor::CompressYUV420Frame(YUV420Frame frame) {
           dmgr.buffer_size);
   };
 
-  dmgr.empty_output_buffer = [](j_compress_ptr cinfo __unused) {
+  dmgr.empty_output_buffer = [](j_compress_ptr) {
     ALOGE("%s:%d Out of buffer", __FUNCTION__, __LINE__);
     return 0;
   };
diff --git a/devices/EmulatedCamera/hwl/JpegCompressor.h b/devices/EmulatedCamera/hwl/JpegCompressor.h
index 1ebda72..f7379e7 100644
--- a/devices/EmulatedCamera/hwl/JpegCompressor.h
+++ b/devices/EmulatedCamera/hwl/JpegCompressor.h
@@ -25,7 +25,6 @@
 #include <thread>
 
 #include "Base.h"
-#include "HandleImporter.h"
 
 extern "C" {
 #include <jpeglib.h>
@@ -35,7 +34,6 @@ extern "C" {
 
 namespace android {
 
-using android::hardware::camera::common::V1_0::helper::HandleImporter;
 using google_camera_hal::BufferStatus;
 using google_camera_hal::HwlPipelineCallback;
 using google_camera_hal::HwlPipelineResult;
diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json
index 3f1e61e..97318f8 100644
--- a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json
+++ b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json
@@ -73,7 +73,8 @@
  ], 
  "android.control.availableVideoStabilizationModes": [
    "0", 
-   "1"
+   "1",
+   "2"
  ], 
  "android.control.awbAvailableModes": [
   "0", 
@@ -112,7 +113,13 @@
  ], 
  "android.flash.info.available": [
   "TRUE"
- ], 
+ ],
+  "android.flash.info.strengthMaximumLevel": [
+  "10"
+ ],
+  "android.flash.info.strengthDefaultLevel": [
+  "3"
+ ],
  "android.hotPixel.availableHotPixelModes": [
   "0", 
   "1", 
@@ -174,7 +181,9 @@
   "BURST_CAPTURE", 
   "PRIVATE_REPROCESSING", 
   "YUV_REPROCESSING", 
-  "RAW"
+  "RAW", 
+  "DYNAMIC_RANGE_TEN_BIT",
+  "STREAM_USE_CASE"
  ], 
  "android.sensor.referenceIlluminant1": [
   "D50"
@@ -186,6 +195,14 @@
  "android.request.maxNumInputStreams": [
   "1"
  ], 
+ "android.request.availableDynamicRangeProfilesMap": [
+  "2", 
+  "3", 
+  "0"
+ ], 
+ "android.request.recommendedTenBitDynamicRangeProfile": [
+  "2"
+ ], 
  "android.scaler.availableInputOutputFormatsMap": [
   "34", 
   "2", 
@@ -196,6 +213,14 @@
   "33", 
   "35"
  ], 
+ "android.scaler.availableStreamUseCases": [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+ ],
  "android.reprocess.maxCaptureStall": [
   "2"
  ], 
@@ -437,7 +462,7 @@
   "1"
  ], 
  "android.request.pipelineMaxDepth": [
-  "4"
+  "8"
  ], 
  "android.scaler.availableMaxDigitalZoom": [
   "10.00000000"
@@ -456,18 +481,34 @@
   "1856", 
   "1392", 
   "33331760", 
+  "54", 
+  "1856", 
+  "1392", 
+  "33331760", 
   "33", 
   "1280", 
   "720", 
   "33331760", 
+  "54", 
+  "1280", 
+  "720", 
+  "33331760", 
   "34", 
   "160", 
   "120", 
   "33331760", 
+  "54", 
+  "160", 
+  "120", 
+  "33331760", 
   "34", 
   "320", 
   "240", 
   "33331760", 
+  "54", 
+  "320", 
+  "240", 
+  "33331760", 
   "35", 
   "160", 
   "120", 
@@ -492,6 +533,10 @@
   "640", 
   "480", 
   "33331760", 
+  "54", 
+  "640", 
+  "480", 
+  "33331760", 
   "34", 
   "1280", 
   "720", 
@@ -524,6 +569,10 @@
   "176", 
   "144", 
   "33331760", 
+  "54", 
+  "176", 
+  "144", 
+  "33331760", 
   "34", 
   "1024", 
   "768", 
@@ -558,6 +607,10 @@
   "1024", 
   "768", 
   "33331760", 
+  "54", 
+  "1024", 
+  "768", 
+  "0", 
   "34", 
   "160", 
   "120", 
@@ -570,6 +623,10 @@
   "160", 
   "120", 
   "0", 
+  "54", 
+  "160", 
+  "120", 
+  "0", 
   "35", 
   "320", 
   "240", 
@@ -578,6 +635,10 @@
   "320", 
   "240", 
   "0", 
+  "54", 
+  "320", 
+  "240", 
+  "0", 
   "34", 
   "640", 
   "480", 
@@ -590,6 +651,10 @@
   "640", 
   "480", 
   "33331760", 
+  "54", 
+  "640", 
+  "480", 
+  "0", 
   "34", 
   "1280", 
   "720", 
@@ -602,10 +667,18 @@
   "1280", 
   "720", 
   "0", 
+  "54", 
+  "1280", 
+  "720", 
+  "0", 
   "35", 
   "1856", 
   "1392", 
   "0", 
+  "54", 
+  "1856", 
+  "1392", 
+  "0", 
   "1", 
   "1600", 
   "1200", 
@@ -632,10 +705,18 @@
   "160", 
   "120", 
   "OUTPUT", 
+  "54", 
+  "160", 
+  "120", 
+  "OUTPUT", 
   "34", 
   "320", 
   "240", 
   "OUTPUT", 
+  "54", 
+  "320", 
+  "240", 
+  "OUTPUT", 
   "35", 
   "160", 
   "120", 
@@ -660,6 +741,10 @@
   "640", 
   "480", 
   "OUTPUT", 
+  "54", 
+  "640", 
+  "480", 
+  "OUTPUT", 
   "34", 
   "1280", 
   "720", 
@@ -676,6 +761,10 @@
   "1280", 
   "720", 
   "OUTPUT", 
+  "54", 
+  "1280", 
+  "720", 
+  "OUTPUT", 
   "35", 
   "1856", 
   "1392", 
@@ -684,6 +773,10 @@
   "1856", 
   "1392", 
   "OUTPUT", 
+  "54", 
+  "1856", 
+  "1392", 
+  "OUTPUT", 
   "INPUT", 
   "1600", 
   "1200", 
@@ -700,6 +793,10 @@
   "176", 
   "144", 
   "OUTPUT", 
+  "54", 
+  "176", 
+  "144", 
+  "OUTPUT", 
   "34", 
   "1024", 
   "768", 
diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_front.json b/devices/EmulatedCamera/hwl/configs/emu_camera_front.json
index e406561..88b70e0 100644
--- a/devices/EmulatedCamera/hwl/configs/emu_camera_front.json
+++ b/devices/EmulatedCamera/hwl/configs/emu_camera_front.json
@@ -182,6 +182,12 @@
   "android.flash.info.available": [
    "TRUE"
   ], 
+  "android.flash.info.strengthMaximumLevel": [
+  "10"
+ ],
+  "android.flash.info.strengthDefaultLevel": [
+  "3"
+ ],
   "android.hotPixel.availableHotPixelModes": [
    "0", 
    "1", 
@@ -296,7 +302,16 @@
    "ULTRA_HIGH_RESOLUTION_SENSOR",
    "YUV_REPROCESSING", 
    "RAW",
-   "REMOSAIC_REPROCESSING"
+   "REMOSAIC_REPROCESSING", 
+   "DYNAMIC_RANGE_TEN_BIT"
+  ], 
+  "android.request.availableDynamicRangeProfilesMap": [
+   "2", 
+   "2", 
+   "0"
+  ], 
+  "android.request.recommendedTenBitDynamicRangeProfile": [
+   "2"
   ], 
   "android.request.maxNumInputStreams": [
    "1"
@@ -495,6 +510,7 @@
    "65537", 
    "65539", 
    "65540", 
+   "65538", 
    "65567", 
    "65543", 
    "65544", 
@@ -582,6 +598,66 @@
    "8.00000000"
   ], 
   "android.scaler.availableMinFrameDurations": [
+   "54", 
+   "1920", 
+   "1440", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1600", 
+   "1200", 
+   "33331760", 
+   "54", 
+   "1440", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "720", 
+   "33331760", 
+   "54", 
+   "1024", 
+   "768", 
+   "33331760", 
+   "54", 
+   "800", 
+   "600", 
+   "33331760", 
+   "54", 
+   "720", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "360", 
+   "33331760", 
+   "54", 
+   "352", 
+   "288", 
+   "33331760", 
+   "54", 
+   "320", 
+   "240", 
+   "33331760", 
+   "54", 
+   "176", 
+   "144", 
+   "33331760", 
    "32",
    "1920",
    "1440",
@@ -858,6 +934,66 @@
    "287539200"
    ],
   "android.scaler.availableStreamConfigurations": [
+   "54", 
+   "1920", 
+   "1440", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1600", 
+   "1200", 
+   "OUTPUT", 
+   "54", 
+   "1440", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "720", 
+   "OUTPUT", 
+   "54", 
+   "1024", 
+   "768", 
+   "OUTPUT", 
+   "54", 
+   "800", 
+   "600", 
+   "OUTPUT", 
+   "54", 
+   "720", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "360", 
+   "OUTPUT", 
+   "54", 
+   "352", 
+   "288", 
+   "OUTPUT", 
+   "54", 
+   "320", 
+   "240", 
+   "OUTPUT", 
+   "54", 
+   "176", 
+   "144", 
+   "OUTPUT", 
    "32",
    "1920",
    "1440",
@@ -1604,7 +1740,16 @@
    "ULTRA_HIGH_RESOLUTION_SENSOR",
    "YUV_REPROCESSING", 
    "RAW",
-   "REMOSAIC_REPROCESSING"
+   "REMOSAIC_REPROCESSING", 
+   "DYNAMIC_RANGE_TEN_BIT"
+  ], 
+  "android.request.availableDynamicRangeProfilesMap": [
+   "2", 
+   "2", 
+   "0"
+  ], 
+  "android.request.recommendedTenBitDynamicRangeProfile": [
+   "2"
   ], 
   "android.request.maxNumInputStreams": [
    "1"
@@ -1807,6 +1952,7 @@
    "65544", 
    "65568", 
    "65547", 
+   "65538", 
    "65570", 
    "65551", 
    "65576", 
@@ -1888,6 +2034,66 @@
    "8.00000000"
   ], 
   "android.scaler.availableMinFrameDurations": [
+   "54", 
+   "1920", 
+   "1440", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1600", 
+   "1200", 
+   "33331760", 
+   "54", 
+   "1440", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "720", 
+   "33331760", 
+   "54", 
+   "1024", 
+   "768", 
+   "33331760", 
+   "54", 
+   "800", 
+   "600", 
+   "33331760", 
+   "54", 
+   "720", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "360", 
+   "33331760", 
+   "54", 
+   "352", 
+   "288", 
+   "33331760", 
+   "54", 
+   "320", 
+   "240", 
+   "33331760", 
+   "54", 
+   "176", 
+   "144", 
+   "33331760", 
    "32",
    "1920",
    "1440",
@@ -2164,6 +2370,66 @@
    "287539200"
    ],
   "android.scaler.availableStreamConfigurations": [
+   "54", 
+   "1920", 
+   "1440", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1600", 
+   "1200", 
+   "OUTPUT", 
+   "54", 
+   "1440", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "720", 
+   "OUTPUT", 
+   "54", 
+   "1024", 
+   "768", 
+   "OUTPUT", 
+   "54", 
+   "800", 
+   "600", 
+   "OUTPUT", 
+   "54", 
+   "720", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "360", 
+   "OUTPUT", 
+   "54", 
+   "352", 
+   "288", 
+   "OUTPUT", 
+   "54", 
+   "320", 
+   "240", 
+   "OUTPUT", 
+   "54", 
+   "176", 
+   "144", 
+   "OUTPUT", 
    "32",
    "1920",
    "1440",
@@ -2933,7 +3199,16 @@
    "ULTRA_HIGH_RESOLUTION_SENSOR",
    "YUV_REPROCESSING", 
    "RAW",
-   "REMOSAIC_REPROCESSING"
+   "REMOSAIC_REPROCESSING", 
+   "DYNAMIC_RANGE_TEN_BIT"
+  ], 
+  "android.request.availableDynamicRangeProfilesMap": [
+   "2", 
+   "2", 
+   "0"
+  ], 
+  "android.request.recommendedTenBitDynamicRangeProfile": [
+   "2"
   ], 
   "android.request.maxNumInputStreams": [
    "1"
@@ -3134,6 +3409,7 @@
    "65567", 
    "65543", 
    "65544", 
+   "65538", 
    "65568", 
    "65547", 
    "65570", 
@@ -3217,6 +3493,70 @@
    "8.00000000"
   ], 
   "android.scaler.availableMinFrameDurations": [
+   "54", 
+   "2048", 
+   "1536", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "1440", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1920", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1600", 
+   "1200", 
+   "33331760", 
+   "54", 
+   "1440", 
+   "1080", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "960", 
+   "33331760", 
+   "54", 
+   "1280", 
+   "720", 
+   "33331760", 
+   "54", 
+   "1024", 
+   "768", 
+   "33331760", 
+   "54", 
+   "800", 
+   "600", 
+   "33331760", 
+   "54", 
+   "720", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "480", 
+   "33331760", 
+   "54", 
+   "640", 
+   "360", 
+   "33331760", 
+   "54", 
+   "352", 
+   "288", 
+   "33331760", 
+   "54", 
+   "320", 
+   "240", 
+   "33331760", 
+   "54", 
+   "176", 
+   "144", 
+   "33331760", 
    "32",
    "2048",
    "1536",
@@ -3517,6 +3857,70 @@
    "287539200"
    ],
   "android.scaler.availableStreamConfigurations": [
+   "54", 
+   "2048", 
+   "1536", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "1440", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1920", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1600", 
+   "1200", 
+   "OUTPUT", 
+   "54", 
+   "1440", 
+   "1080", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "960", 
+   "OUTPUT", 
+   "54", 
+   "1280", 
+   "720", 
+   "OUTPUT", 
+   "54", 
+   "1024", 
+   "768", 
+   "OUTPUT", 
+   "54", 
+   "800", 
+   "600", 
+   "OUTPUT", 
+   "54", 
+   "720", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "480", 
+   "OUTPUT", 
+   "54", 
+   "640", 
+   "360", 
+   "OUTPUT", 
+   "54", 
+   "352", 
+   "288", 
+   "OUTPUT", 
+   "54", 
+   "320", 
+   "240", 
+   "OUTPUT", 
+   "54", 
+   "176", 
+   "144", 
+   "OUTPUT", 
    "34", 
    "2048", 
    "1536", 
diff --git a/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp b/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp
index c50297e..b444465 100644
--- a/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp
+++ b/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <unordered_set>
 #define LOG_TAG "HWLUtils"
 #include "HWLUtils.h"
 #include <log/log.h>
@@ -61,6 +62,46 @@ status_t GetSensorCharacteristics(const HalCameraMetadata* metadata,
   sensor_chars->max_processed_streams = entry.data.i32[1];
   sensor_chars->max_stalling_streams = entry.data.i32[2];
 
+  if (HasCapability(
+          metadata,
+          ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)) {
+    ret = metadata->Get(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP,
+                        &entry);
+    if ((ret != OK) || ((entry.count % 3) != 0)) {
+      ALOGE("%s: Invalid ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP!",
+            __FUNCTION__);
+      return BAD_VALUE;
+    }
+
+    for (size_t i = 0; i < entry.count; i += 3) {
+      sensor_chars->dynamic_range_profiles.emplace(
+          static_cast<
+              camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
+              entry.data.i64[i]),
+          std::unordered_set<
+              camera_metadata_enum_android_request_available_dynamic_range_profiles_map>());
+      const auto profile_end =
+          ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO
+          << 1;
+      uint64_t current_profile =
+          ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
+      for (; current_profile != profile_end; current_profile <<= 1) {
+        if (entry.data.i64[i + 1] & current_profile) {
+          sensor_chars->dynamic_range_profiles
+              .at(static_cast<
+                  camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
+                  entry.data.i64[i]))
+              .emplace(
+                  static_cast<
+                      camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
+                      current_profile));
+        }
+      }
+    }
+
+    sensor_chars->is_10bit_dynamic_range_capable = true;
+  }
+
   if (HasCapability(metadata,
                     ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR)) {
     ret = metadata->Get(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, &entry);
@@ -213,6 +254,14 @@ status_t GetSensorCharacteristics(const HalCameraMetadata* metadata,
     ALOGE("%s: Lens facing absent!", __FUNCTION__);
     return BAD_VALUE;
   }
+
+  if (HasCapability(metadata,
+                    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE)) {
+    sensor_chars->support_stream_use_case = true;
+  } else {
+    sensor_chars->support_stream_use_case = false;
+  }
+
   return ret;
 }