/*
 * 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 "EmulatedCameraProviderHwlImpl"
#include "EmulatedCameraProviderHWLImpl.h"

#include <android-base/file.h>
#include <android-base/strings.h>
#include <cutils/properties.h>
#include <hardware/camera_common.h>
#include <log/log.h>

#include "EmulatedCameraDeviceHWLImpl.h"
#include "EmulatedCameraDeviceSessionHWLImpl.h"
#include "EmulatedLogicalRequestState.h"
#include "EmulatedSensor.h"
#include "EmulatedTorchState.h"
#include "utils/HWLUtils.h"
#include "vendor_tag_defs.h"

namespace android {

// Location of the camera configuration files.
constexpr std::string_view kCameraConfigBack = "emu_camera_back.json";
constexpr std::string_view kCameraConfigFront = "emu_camera_front.json";
constexpr std::string_view kCameraConfigExternal = "emu_camera_external.json";
constexpr std::string_view kCameraConfigDepth = "emu_camera_depth.json";
constexpr std::string_view kCameraConfigFiles[] = {
    kCameraConfigBack, kCameraConfigFront, kCameraConfigExternal,
    kCameraConfigDepth};

constexpr std::string_view kConfigurationFileDirVendor = "/vendor/etc/config/";
constexpr std::string_view kConfigurationFileDirApex =
    "/apex/com.google.emulated.camera.provider.hal/etc/config/";

constexpr StreamSize s240pStreamSize = std::pair(240, 180);
constexpr StreamSize s720pStreamSize = std::pair(1280, 720);
constexpr StreamSize s1440pStreamSize = std::pair(1920, 1440);

std::unique_ptr<EmulatedCameraProviderHwlImpl>
EmulatedCameraProviderHwlImpl::Create() {
  auto provider = std::unique_ptr<EmulatedCameraProviderHwlImpl>(
      new EmulatedCameraProviderHwlImpl());

  if (provider == nullptr) {
    ALOGE("%s: Creating EmulatedCameraProviderHwlImpl failed.", __FUNCTION__);
    return nullptr;
  }

  status_t res = provider->Initialize();
  if (res != OK) {
    ALOGE("%s: Initializing EmulatedCameraProviderHwlImpl failed: %s (%d).",
          __FUNCTION__, strerror(-res), res);
    return nullptr;
  }

  ALOGI("%s: Created EmulatedCameraProviderHwlImpl", __FUNCTION__);

  return provider;
}

status_t EmulatedCameraProviderHwlImpl::GetTagFromName(const char* name,
                                                       uint32_t* tag) {
  if (name == nullptr || tag == nullptr) {
    return BAD_VALUE;
  }

  size_t name_length = strlen(name);
  // First, find the section by the longest string match
  const char* section = NULL;
  size_t section_index = 0;
  size_t section_length = 0;
  for (size_t i = 0; i < ANDROID_SECTION_COUNT; ++i) {
    const char* str = camera_metadata_section_names[i];

    ALOGV("%s: Trying to match against section '%s'", __FUNCTION__, str);

    if (strstr(name, str) == name) {  // name begins with the section name
      size_t str_length = strlen(str);

      ALOGV("%s: Name begins with section name", __FUNCTION__);

      // section name is the longest we've found so far
      if (section == NULL || section_length < str_length) {
        section = str;
        section_index = i;
        section_length = str_length;

        ALOGV("%s: Found new best section (%s)", __FUNCTION__, section);
      }
    }
  }

  if (section == NULL) {
    return NAME_NOT_FOUND;
  } else {
    ALOGV("%s: Found matched section '%s' (%zu)", __FUNCTION__, section,
          section_index);
  }

  // Get the tag name component of the name
  const char* name_tag_name = name + section_length + 1;  // x.y.z -> z
  if (section_length + 1 >= name_length) {
    return BAD_VALUE;
  }

  // Match rest of name against the tag names in that section only
  uint32_t candidate_tag = 0;
  // Match built-in tags (typically android.*)
  uint32_t tag_begin, tag_end;  // [tag_begin, tag_end)
  tag_begin = camera_metadata_section_bounds[section_index][0];
  tag_end = camera_metadata_section_bounds[section_index][1];

  for (candidate_tag = tag_begin; candidate_tag < tag_end; ++candidate_tag) {
    const char* tag_name = get_camera_metadata_tag_name(candidate_tag);

    if (strcmp(name_tag_name, tag_name) == 0) {
      ALOGV("%s: Found matched tag '%s' (%d)", __FUNCTION__, tag_name,
            candidate_tag);
      break;
    }
  }

  if (candidate_tag == tag_end) {
    return NAME_NOT_FOUND;
  }

  *tag = candidate_tag;
  return OK;
}

static bool IsMaxSupportedSizeGreaterThanOrEqual(
    const std::set<StreamSize>& stream_sizes, StreamSize compare_size) {
  for (const auto& stream_size : stream_sizes) {
    if (stream_size.first * stream_size.second >=
        compare_size.first * compare_size.second) {
      return true;
    }
  }
  return false;
}

static bool SupportsCapability(const uint32_t camera_id,
                               const HalCameraMetadata& static_metadata,
                               uint8_t cap) {
  camera_metadata_ro_entry_t entry;
  auto ret = static_metadata.Get(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, &entry);
  if (ret != OK || (entry.count == 0)) {
    ALOGE("Error getting capabilities for camera id %u", camera_id);
    return false;
  }
  for (size_t i = 0; i < entry.count; i++) {
    if (entry.data.u8[i] == cap) {
      return true;
    }
  }
  return false;
}

bool EmulatedCameraProviderHwlImpl::SupportsMandatoryConcurrentStreams(
    uint32_t camera_id) {
  HalCameraMetadata& static_metadata = *(static_metadata_[camera_id]);
  auto map = std::make_unique<StreamConfigurationMap>(static_metadata);
  auto yuv_output_sizes = map->GetOutputSizes(HAL_PIXEL_FORMAT_YCBCR_420_888);
  auto blob_output_sizes = map->GetOutputSizes(HAL_PIXEL_FORMAT_BLOB);
  auto depth16_output_sizes = map->GetOutputSizes(HAL_PIXEL_FORMAT_Y16);
  auto priv_output_sizes =
      map->GetOutputSizes(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);

  if (!SupportsCapability(
          camera_id, static_metadata,
          ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) &&
      IsMaxSupportedSizeGreaterThanOrEqual(depth16_output_sizes,
                                           s240pStreamSize)) {
    ALOGI("%s: Depth only output supported by camera id %u", __FUNCTION__,
          camera_id);
    return true;
  }
  if (yuv_output_sizes.empty()) {
    ALOGW("%s: No YUV output supported by camera id %u", __FUNCTION__,
          camera_id);
    return false;
  }

  if (priv_output_sizes.empty()) {
    ALOGW("No PRIV output supported by camera id %u", camera_id);
    return false;
  }

  if (blob_output_sizes.empty()) {
    ALOGW("No BLOB output supported by camera id %u", camera_id);
    return false;
  }

  // According to the HAL spec, if a device supports format sizes > 1440p and
  // 720p, it must support both 1440p and 720p streams for PRIV, JPEG and YUV
  // formats. Otherwise it must support 2 streams (YUV / PRIV + JPEG) of the max
  // supported size.

  // Check for YUV output sizes
  if (IsMaxSupportedSizeGreaterThanOrEqual(yuv_output_sizes, s1440pStreamSize) &&
      (yuv_output_sizes.find(s1440pStreamSize) == yuv_output_sizes.end() ||
       yuv_output_sizes.find(s720pStreamSize) == yuv_output_sizes.end())) {
    ALOGW("%s: 1440p+720p YUV outputs not found for camera id %u", __FUNCTION__,
          camera_id);
    return false;
  } else if (IsMaxSupportedSizeGreaterThanOrEqual(yuv_output_sizes,
                                                  s720pStreamSize) &&
             yuv_output_sizes.find(s720pStreamSize) == yuv_output_sizes.end()) {
    ALOGW("%s: 720p YUV output not found for camera id %u", __FUNCTION__,
          camera_id);
    return false;
  }

  // Check for PRIV output sizes
  if (IsMaxSupportedSizeGreaterThanOrEqual(priv_output_sizes, s1440pStreamSize) &&
      (priv_output_sizes.find(s1440pStreamSize) == priv_output_sizes.end() ||
       priv_output_sizes.find(s720pStreamSize) == priv_output_sizes.end())) {
    ALOGW("%s: 1440p + 720p PRIV outputs not found for camera id %u",
          __FUNCTION__, camera_id);
    return false;
  } else if (IsMaxSupportedSizeGreaterThanOrEqual(priv_output_sizes,
                                                  s720pStreamSize) &&
             priv_output_sizes.find(s720pStreamSize) == priv_output_sizes.end()) {
    ALOGW("%s: 720p PRIV output not found for camera id %u", __FUNCTION__,
          camera_id);
    return false;
  }

  // Check for BLOB output sizes
  if (IsMaxSupportedSizeGreaterThanOrEqual(blob_output_sizes, s1440pStreamSize) &&
      (blob_output_sizes.find(s1440pStreamSize) == blob_output_sizes.end() ||
       blob_output_sizes.find(s720pStreamSize) == blob_output_sizes.end())) {
    ALOGW("%s: 1440p + 720p BLOB outputs not found for camera id %u",
          __FUNCTION__, camera_id);
    return false;
  } else if (IsMaxSupportedSizeGreaterThanOrEqual(blob_output_sizes,
                                                  s720pStreamSize) &&
             blob_output_sizes.find(s720pStreamSize) == blob_output_sizes.end()) {
    ALOGW("%s: 720p BLOB output not found for camera id %u", __FUNCTION__,
          camera_id);
    return false;
  }

  return true;
}

status_t EmulatedCameraProviderHwlImpl::GetConcurrentStreamingCameraIds(
    std::vector<std::unordered_set<uint32_t>>* combinations) {
  if (combinations == nullptr) {
    return BAD_VALUE;
  }
  // Collect all camera ids that support the guaranteed stream combinations
  // (720p YUV and IMPLEMENTATION_DEFINED) and put them in one set. We don't
  // make all possible combinations since it should be possible to stream all
  // of them at once in the emulated camera.
  std::unordered_set<uint32_t> candidate_ids;
  for (auto& entry : camera_id_map_) {
    if (SupportsMandatoryConcurrentStreams(entry.first)) {
      candidate_ids.insert(entry.first);
    }
  }
  combinations->emplace_back(std::move(candidate_ids));
  return OK;
}

status_t EmulatedCameraProviderHwlImpl::IsConcurrentStreamCombinationSupported(
    const std::vector<CameraIdAndStreamConfiguration>& configs,
    bool* is_supported) {
  *is_supported = false;

  // Go through the given camera ids, get their sensor characteristics, stream
  // config maps and call EmulatedSensor::IsStreamCombinationSupported()
  for (auto& config : configs) {
    // TODO: Consider caching sensor characteristics and StreamConfigurationMap
    if (camera_id_map_.find(config.camera_id) == camera_id_map_.end()) {
      ALOGE("%s: Camera id %u does not exist", __FUNCTION__, config.camera_id);
      return BAD_VALUE;
    }

    auto stream_configuration_map = std::make_unique<StreamConfigurationMap>(
        *(static_metadata_[config.camera_id]));
    auto stream_configuration_map_max_resolution =
        std::make_unique<StreamConfigurationMap>(
            *(static_metadata_[config.camera_id]), /*maxResolution*/ true);

    LogicalCharacteristics sensor_chars;
    status_t ret =
        GetSensorCharacteristics((static_metadata_[config.camera_id]).get(),
                                 &sensor_chars[config.camera_id]);
    if (ret != OK) {
      ALOGE("%s: Unable to extract sensor chars for camera id %u", __FUNCTION__,
            config.camera_id);
      return UNKNOWN_ERROR;
    }

    PhysicalStreamConfigurationMap physical_stream_configuration_map;
    PhysicalStreamConfigurationMap physical_stream_configuration_map_max_resolution;
    auto const& physicalCameraInfo = camera_id_map_[config.camera_id];
    for (size_t i = 0; i < physicalCameraInfo.size(); i++) {
      uint32_t physical_camera_id = physicalCameraInfo[i].second;
      physical_stream_configuration_map.emplace(
          physical_camera_id, std::make_unique<StreamConfigurationMap>(
                                  *(static_metadata_[physical_camera_id])));

      physical_stream_configuration_map_max_resolution.emplace(
          physical_camera_id,
          std::make_unique<StreamConfigurationMap>(
              *(static_metadata_[physical_camera_id]), /*maxResolution*/ true));

      ret = GetSensorCharacteristics(static_metadata_[physical_camera_id].get(),
                                     &sensor_chars[physical_camera_id]);
      if (ret != OK) {
        ALOGE("%s: Unable to extract camera %d sensor characteristics %s (%d)",
              __FUNCTION__, physical_camera_id, strerror(-ret), ret);
        return ret;
      }
    }

    if (!EmulatedSensor::IsStreamCombinationSupported(
            config.camera_id, config.stream_configuration,
            *stream_configuration_map, *stream_configuration_map_max_resolution,
            physical_stream_configuration_map,
            physical_stream_configuration_map_max_resolution, sensor_chars)) {
      return OK;
    }
  }

  *is_supported = true;
  return OK;
}

bool IsDigit(const std::string& value) {
  if (value.empty()) {
    return false;
  }

  for (const auto& c : value) {
    if (!std::isdigit(c) && (!std::ispunct(c))) {
      return false;
    }
  }

  return true;
}

template <typename T>
status_t GetEnumValue(uint32_t tag_id, const char* cstring, T* result /*out*/) {
  if ((result == nullptr) || (cstring == nullptr)) {
    return BAD_VALUE;
  }

  uint32_t enum_value;
  auto ret =
      camera_metadata_enum_value(tag_id, cstring, strlen(cstring), &enum_value);
  if (ret != OK) {
    ALOGE("%s: Failed to match tag id: 0x%x value: %s", __FUNCTION__, tag_id,
          cstring);
    return ret;
  }
  *result = enum_value;

  return OK;
}

status_t GetUInt8Value(const Json::Value& value, uint32_t tag_id,
                       uint8_t* result /*out*/) {
  if (result == nullptr) {
    return BAD_VALUE;
  }

  if (value.isString()) {
    errno = 0;
    if (IsDigit(value.asString())) {
      auto int_value = strtol(value.asCString(), nullptr, 10);
      if ((int_value >= 0) && (int_value <= UINT8_MAX) && (errno == 0)) {
        *result = int_value;
      } else {
        ALOGE("%s: Failed parsing tag id 0x%x", __func__, tag_id);
        return BAD_VALUE;
      }
    } else {
      return GetEnumValue(tag_id, value.asCString(), result);
    }
  } else {
    ALOGE(
        "%s: Unexpected json type: %d! All value types are expected to be "
        "strings!",
        __FUNCTION__, value.type());
    return BAD_VALUE;
  }

  return OK;
}

status_t GetInt32Value(const Json::Value& value, uint32_t tag_id,
                       int32_t* result /*out*/) {
  if (result == nullptr) {
    return BAD_VALUE;
  }

  if (value.isString()) {
    errno = 0;
    if (IsDigit(value.asString())) {
      auto int_value = strtol(value.asCString(), nullptr, 10);
      if ((int_value >= INT32_MIN) && (int_value <= INT32_MAX) && (errno == 0)) {
        *result = int_value;
      } else {
        ALOGE("%s: Failed parsing tag id 0x%x", __func__, tag_id);
        return BAD_VALUE;
      }
    } else {
      return GetEnumValue(tag_id, value.asCString(), result);
    }
  } else {
    ALOGE(
        "%s: Unexpected json type: %d! All value types are expected to be "
        "strings!",
        __FUNCTION__, value.type());
    return BAD_VALUE;
  }

  return OK;
}

status_t GetInt64Value(const Json::Value& value, uint32_t tag_id,
                       int64_t* result /*out*/) {
  if (result == nullptr) {
    return BAD_VALUE;
  }

  if (value.isString()) {
    errno = 0;
    auto int_value = strtoll(value.asCString(), nullptr, 10);
    if ((int_value >= INT64_MIN) && (int_value <= INT64_MAX) && (errno == 0)) {
      *result = int_value;
    } else {
      ALOGE("%s: Failed parsing tag id 0x%x", __func__, tag_id);
      return BAD_VALUE;
    }
  } else {
    ALOGE(
        "%s: Unexpected json type: %d! All value types are expected to be "
        "strings!",
        __FUNCTION__, value.type());
    return BAD_VALUE;
  }

  return OK;
}

status_t GetFloatValue(const Json::Value& value, uint32_t tag_id,
                       float* result /*out*/) {
  if (result == nullptr) {
    return BAD_VALUE;
  }

  if (value.isString()) {
    errno = 0;
    auto float_value = strtof(value.asCString(), nullptr);
    if (errno == 0) {
      *result = float_value;
    } else {
      ALOGE("%s: Failed parsing tag id 0x%x", __func__, tag_id);
      return BAD_VALUE;
    }
  } else {
    ALOGE(
        "%s: Unexpected json type: %d! All value types are expected to be "
        "strings!",
        __FUNCTION__, value.type());
    return BAD_VALUE;
  }

  return OK;
}

status_t GetDoubleValue(const Json::Value& value, uint32_t tag_id,
                        double* result /*out*/) {
  if (result == nullptr) {
    return BAD_VALUE;
  }

  if (value.isString()) {
    errno = 0;
    auto double_value = strtod(value.asCString(), nullptr);
    if (errno == 0) {
      *result = double_value;
    } else {
      ALOGE("%s: Failed parsing tag id 0x%x", __func__, tag_id);
      return BAD_VALUE;
    }
  } else {
    ALOGE(
        "%s: Unexpected json type: %d! All value types are expected to be "
        "strings!",
        __FUNCTION__, value.type());
    return BAD_VALUE;
  }

  return OK;
}

template <typename T>
void FilterVendorKeys(uint32_t tag_id, std::vector<T>* values) {
  if ((values == nullptr) || (values->empty())) {
    return;
  }

  switch (tag_id) {
    case ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS:
    case ANDROID_REQUEST_AVAILABLE_RESULT_KEYS:
    case ANDROID_REQUEST_AVAILABLE_SESSION_KEYS:
    case ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: {
      auto it = values->begin();
      while (it != values->end()) {
        // Per spec. the tags we are handling here will be "int32_t".
        // In this case all vendor defined values will be negative.
        if (*it < 0) {
          it = values->erase(it);
        } else {
          it++;
        }
      }
    } break;
    default:
      // no-op
      break;
  }
}

template <typename T, typename func_type>
status_t InsertTag(const Json::Value& json_value, uint32_t tag_id,
                   func_type get_val_func, HalCameraMetadata* meta /*out*/) {
  if (meta == nullptr) {
    return BAD_VALUE;
  }

  std::vector<T> values;
  T result;
  status_t ret = -1;
  values.reserve(json_value.size());
  for (const auto& val : json_value) {
    ret = get_val_func(val, tag_id, &result);
    if (ret != OK) {
      break;
    }

    values.push_back(result);
  }

  if (ret == OK) {
    FilterVendorKeys(tag_id, &values);
    ret = meta->Set(tag_id, values.data(), values.size());
  }

  return ret;
}

status_t InsertRationalTag(const Json::Value& json_value, uint32_t tag_id,
                           HalCameraMetadata* meta /*out*/) {
  if (meta == nullptr) {
    return BAD_VALUE;
  }

  std::vector<camera_metadata_rational_t> values;
  status_t ret = OK;
  if (json_value.isArray() && ((json_value.size() % 2) == 0)) {
    values.reserve(json_value.size() / 2);
    auto it = json_value.begin();
    while (it != json_value.end()) {
      camera_metadata_rational_t result;
      ret = GetInt32Value((*it), tag_id, &result.numerator);
      it++;
      ret |= GetInt32Value((*it), tag_id, &result.denominator);
      it++;
      if (ret != OK) {
        break;
      }
      values.push_back(result);
    }
  } else {
    ALOGE("%s: json type: %d doesn't match with rational tag type",
          __FUNCTION__, json_value.type());
    return BAD_VALUE;
  }

  if (ret == OK) {
    ret = meta->Set(tag_id, values.data(), values.size());
  }

  return ret;
}

uint32_t EmulatedCameraProviderHwlImpl::ParseCharacteristics(
    const Json::Value& value, ssize_t id) {
  if (!value.isObject()) {
    ALOGE("%s: Configuration root is not an object", __FUNCTION__);
    return BAD_VALUE;
  }

  auto static_meta = HalCameraMetadata::Create(1, 10);
  auto members = value.getMemberNames();
  for (const auto& member : members) {
    uint32_t tag_id;
    auto stat = GetTagFromName(member.c_str(), &tag_id);
    if (stat != OK) {
      ALOGE("%s: tag %s not supported, skipping!", __func__, member.c_str());
      continue;
    }

    auto tag_type = get_camera_metadata_tag_type(tag_id);
    auto tag_value = value[member.c_str()];
    switch (tag_type) {
      case TYPE_BYTE:
        InsertTag<uint8_t>(tag_value, tag_id, GetUInt8Value, static_meta.get());
        break;
      case TYPE_INT32:
        InsertTag<int32_t>(tag_value, tag_id, GetInt32Value, static_meta.get());
        break;
      case TYPE_INT64:
        InsertTag<int64_t>(tag_value, tag_id, GetInt64Value, static_meta.get());
        break;
      case TYPE_FLOAT:
        InsertTag<float>(tag_value, tag_id, GetFloatValue, static_meta.get());
        break;
      case TYPE_DOUBLE:
        InsertTag<double>(tag_value, tag_id, GetDoubleValue, static_meta.get());
        break;
      case TYPE_RATIONAL:
        InsertRationalTag(tag_value, tag_id, static_meta.get());
        break;
      default:
        ALOGE("%s: Unsupported tag type: %d!", __FUNCTION__, tag_type);
    }
  }

  SensorCharacteristics sensor_characteristics;
  auto ret =
      GetSensorCharacteristics(static_meta.get(), &sensor_characteristics);
  if (ret != OK) {
    ALOGE("%s: Unable to extract sensor characteristics!", __FUNCTION__);
    return ret;
  }

  if (!EmulatedSensor::AreCharacteristicsSupported(sensor_characteristics)) {
    ALOGE("%s: Sensor characteristics not supported!", __FUNCTION__);
    return BAD_VALUE;
  }

  // Although we don't support HdrPlus, this data is still required by HWL
  int32_t payload_frames = 0;
  static_meta->Set(google_camera_hal::kHdrplusPayloadFrames, &payload_frames, 1);

  if (id < 0) {
    static_metadata_.push_back(std::move(static_meta));
    id = static_metadata_.size() - 1;
  } else {
    static_metadata_[id] = std::move(static_meta);
  }

  return id;
}

status_t EmulatedCameraProviderHwlImpl::WaitForQemuSfFakeCameraPropertyAvailable() {
  // Camera service may start running before qemu-props sets
  // vendor.qemu.sf.fake_camera to any of the following four values:
  // "none,front,back,both"; so we need to wait.
  int num_attempts = 100;
  char prop[PROPERTY_VALUE_MAX];
  bool timeout = true;
  for (int i = 0; i < num_attempts; ++i) {
    if (property_get("vendor.qemu.sf.fake_camera", prop, nullptr) != 0) {
      timeout = false;
      break;
    }
    usleep(5000);
  }
  if (timeout) {
    ALOGE("timeout (%dms) waiting for property vendor.qemu.sf.fake_camera to be set\n",
          5 * num_attempts);
    return BAD_VALUE;
  }
  return OK;
}

status_t EmulatedCameraProviderHwlImpl::Initialize() {
  // GCH expects all physical ids to be bigger than the logical ones.
  // Resize 'static_metadata_' to fit all logical devices and insert them
  // accordingly, push any remaining physical cameras in the back.
  std::string config;
  size_t logical_id = 0;
  std::vector<std::string> config_file_locations;
  std::string config_dir = "";
  struct stat st;
  if (stat(kConfigurationFileDirApex.data(), &st) == 0) {
    config_dir += kConfigurationFileDirApex.data();
  } else {
    config_dir += kConfigurationFileDirVendor.data();
  }
  char prop[PROPERTY_VALUE_MAX];
  if (!property_get_bool("ro.boot.qemu", false)) {
    // Cuttlefish
    property_get("ro.vendor.camera.config", prop, nullptr);
    if (strcmp(prop, "external") == 0) {
      config_file_locations.emplace_back(config_dir +
                                         kCameraConfigExternal.data());
      logical_id = 1;
    } else {
      // Default phone layout.
      config_file_locations.emplace_back(config_dir + kCameraConfigBack.data());
      config_file_locations.emplace_back(config_dir + kCameraConfigFront.data());
      config_file_locations.emplace_back(config_dir + kCameraConfigDepth.data());
    }
  } else {
    // Android Studio Emulator
    if (!property_get_bool("ro.boot.qemu.legacy_fake_camera", false)) {
      if (WaitForQemuSfFakeCameraPropertyAvailable() == OK) {
        property_get("vendor.qemu.sf.fake_camera", prop, nullptr);
        if (strcmp(prop, "both") == 0) {
          config_file_locations.emplace_back(config_dir +
                                             kCameraConfigBack.data());
          config_file_locations.emplace_back(config_dir +
                                             kCameraConfigFront.data());
        } else if (strcmp(prop, "front") == 0) {
          config_file_locations.emplace_back(config_dir +
                                             kCameraConfigFront.data());
          logical_id = 1;
        } else if (strcmp(prop, "back") == 0) {
          config_file_locations.emplace_back(config_dir +
                                             kCameraConfigBack.data());
          logical_id = 1;
        }
      }
    }
  }
  static_metadata_.resize(ARRAY_SIZE(kCameraConfigFiles));

  for (const auto& config_path : config_file_locations) {
    if (!android::base::ReadFileToString(config_path, &config)) {
      ALOGW("%s: Could not open configuration file: %s", __FUNCTION__,
            config_path.c_str());
      continue;
    }

    Json::CharReaderBuilder builder;
    std::unique_ptr<Json::CharReader> config_reader(builder.newCharReader());
    Json::Value root;
    std::string error_message;
    if (!config_reader->parse(&*config.begin(), &*config.end(), &root,
                              &error_message)) {
      ALOGE("Could not parse configuration file: %s", error_message.c_str());
      return BAD_VALUE;
    }

    if (root.isArray()) {
      auto device_iter = root.begin();
      auto result_id = ParseCharacteristics(*device_iter, logical_id);
      if (logical_id != result_id) {
        return result_id;
      }
      device_iter++;

      // The first device entry is always the logical camera followed by the
      // physical devices. They must be at least 2.
      camera_id_map_.emplace(logical_id, std::vector<std::pair<CameraDeviceStatus, uint32_t>>());
      if (root.size() >= 3) {
        camera_id_map_[logical_id].reserve(root.size() - 1);
        size_t current_physical_device = 0;
        while (device_iter != root.end()) {
          auto physical_id = ParseCharacteristics(*device_iter, /*id*/ -1);
          if (physical_id < 0) {
            return physical_id;
          }
          // Only notify unavailable physical camera if there are more than 2
          // physical cameras backing the logical camera
          auto device_status = (current_physical_device < 2) ? CameraDeviceStatus::kPresent :
              CameraDeviceStatus::kNotPresent;
          camera_id_map_[logical_id].push_back(std::make_pair(device_status, physical_id));
          device_iter++; current_physical_device++;
        }

        auto physical_devices = std::make_unique<PhysicalDeviceMap>();
        for (const auto& physical_device : camera_id_map_[logical_id]) {
          physical_devices->emplace(
              physical_device.second, std::make_pair(physical_device.first,
              HalCameraMetadata::Clone(
                  static_metadata_[physical_device.second].get())));
        }
        auto updated_logical_chars =
            EmulatedLogicalRequestState::AdaptLogicalCharacteristics(
                HalCameraMetadata::Clone(static_metadata_[logical_id].get()),
                std::move(physical_devices));
        if (updated_logical_chars.get() != nullptr) {
          static_metadata_[logical_id].swap(updated_logical_chars);
        } else {
          ALOGE("%s: Failed to updating logical camera characteristics!",
                __FUNCTION__);
          return BAD_VALUE;
        }
      }
    } else {
      auto result_id = ParseCharacteristics(root, logical_id);
      if (result_id != logical_id) {
        return result_id;
      }
      camera_id_map_.emplace(logical_id, std::vector<std::pair<CameraDeviceStatus, uint32_t>>());
    }

    logical_id++;
  }

  return OK;
}

status_t EmulatedCameraProviderHwlImpl::SetCallback(
    const HwlCameraProviderCallback& callback) {
  torch_cb_ = callback.torch_mode_status_change;
  physical_camera_status_cb_ = callback.physical_camera_device_status_change;

  return OK;
}

status_t EmulatedCameraProviderHwlImpl::TriggerDeferredCallbacks() {
  std::lock_guard<std::mutex> lock(status_callback_future_lock_);
  if (status_callback_future_.valid()) {
    return OK;
  }

  status_callback_future_ = std::async(
      std::launch::async,
      &EmulatedCameraProviderHwlImpl::NotifyPhysicalCameraUnavailable, this);
  return OK;
}

void EmulatedCameraProviderHwlImpl::WaitForStatusCallbackFuture() {
  {
    std::lock_guard<std::mutex> lock(status_callback_future_lock_);
    if (!status_callback_future_.valid()) {
      // If there is no future pending, construct a dummy one.
      status_callback_future_ = std::async([]() { return; });
    }
  }
  status_callback_future_.wait();
}

void EmulatedCameraProviderHwlImpl::NotifyPhysicalCameraUnavailable() {
  for (const auto& one_map : camera_id_map_) {
    for (const auto& physical_device : one_map.second) {
      if (physical_device.first != CameraDeviceStatus::kNotPresent) {
        continue;
      }

      uint32_t logical_camera_id = one_map.first;
      uint32_t physical_camera_id = physical_device.second;
      physical_camera_status_cb_(
          logical_camera_id, physical_camera_id,
          CameraDeviceStatus::kNotPresent);
    }
  }
}

status_t EmulatedCameraProviderHwlImpl::GetVendorTags(
    std::vector<VendorTagSection>* vendor_tag_sections) {
  if (vendor_tag_sections == nullptr) {
    ALOGE("%s: vendor_tag_sections is nullptr.", __FUNCTION__);
    return BAD_VALUE;
  }

  // No vendor specific tags as of now
  return OK;
}

status_t EmulatedCameraProviderHwlImpl::GetVisibleCameraIds(
    std::vector<std::uint32_t>* camera_ids) {
  if (camera_ids == nullptr) {
    ALOGE("%s: camera_ids is nullptr.", __FUNCTION__);
    return BAD_VALUE;
  }

  for (const auto& device : camera_id_map_) {
    camera_ids->push_back(device.first);
  }

  return OK;
}

status_t EmulatedCameraProviderHwlImpl::CreateCameraDeviceHwl(
    uint32_t camera_id, std::unique_ptr<CameraDeviceHwl>* camera_device_hwl) {
  if (camera_device_hwl == nullptr) {
    ALOGE("%s: camera_device_hwl is nullptr.", __FUNCTION__);
    return BAD_VALUE;
  }

  if (camera_id_map_.find(camera_id) == camera_id_map_.end()) {
    ALOGE("%s: Invalid camera id: %u", __func__, camera_id);
    return BAD_VALUE;
  }

  std::unique_ptr<HalCameraMetadata> meta =
      HalCameraMetadata::Clone(static_metadata_[camera_id].get());

  std::shared_ptr<EmulatedTorchState> torch_state;
  camera_metadata_ro_entry entry;
  bool flash_supported = false;
  auto ret = meta->Get(ANDROID_FLASH_INFO_AVAILABLE, &entry);
  if ((ret == OK) && (entry.count == 1)) {
    if (entry.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
      flash_supported = true;
    }
  }

  if (flash_supported) {
    torch_state = std::make_shared<EmulatedTorchState>(camera_id, torch_cb_);
  }

  auto physical_devices = std::make_unique<PhysicalDeviceMap>();
  for (const auto& physical_device : camera_id_map_[camera_id]) {
      physical_devices->emplace(
          physical_device.second, std::make_pair(physical_device.first,
          HalCameraMetadata::Clone(static_metadata_[physical_device.second].get())));
  }
  *camera_device_hwl = EmulatedCameraDeviceHwlImpl::Create(
      camera_id, std::move(meta), std::move(physical_devices), torch_state);
  if (*camera_device_hwl == nullptr) {
    ALOGE("%s: Cannot create EmulatedCameraDeviceHWlImpl.", __FUNCTION__);
    return BAD_VALUE;
  }

  return OK;
}

status_t EmulatedCameraProviderHwlImpl::CreateBufferAllocatorHwl(
    std::unique_ptr<CameraBufferAllocatorHwl>* camera_buffer_allocator_hwl) {
  if (camera_buffer_allocator_hwl == nullptr) {
    ALOGE("%s: camera_buffer_allocator_hwl is nullptr.", __FUNCTION__);
    return BAD_VALUE;
  }

  // Currently not supported
  return INVALID_OPERATION;
}

status_t EmulatedCameraProviderHwlImpl::NotifyDeviceStateChange(
    DeviceState /*device_state*/) {
  return OK;
}
}  // namespace android