camera/hal/fake/camera_hal.cc - chromiumos/platform2 - Git at Google

 /* Copyright 2022 The ChromiumOS Authors
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "hal/fake/camera_hal.h"

 #include <algorithm>
 #include <memory>
 #include <utility>

 #include <base/containers/contains.h>
 #include <base/no_destructor.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/task/sequenced_task_runner.h>

 #include "cros-camera/common.h"
 #include "cros-camera/cros_camera_hal.h"

 #include "hal/fake/metadata_handler.h"

 namespace cros {

 namespace {
 // The default fake hal spec file. The file should contain a JSON that is
 // parsed to HalSpec struct.
 constexpr const char kDefaultFakeHalSpecFile[] = "/etc/camera/fake_hal.json";
 constexpr const char kOverrideFakeHalSpecFile[] = "/run/camera/fake_hal.json";

 // This is the sleep time (0.3s) between reporting disconnect and connect event
 // to upper layer, to avoid race condition in Chrome.
 // TODO(b:261682032): Check if the time can be lower, and/or fix the issue in
 // Chrome so this is not needed.
 constexpr const base::TimeDelta kReconnectDelay = base::Milliseconds(300);

 int camera_device_open_ext(const hw_module_t* module,
                            const char* name,
                            hw_device_t** device,
                            ClientType client_type) {
   // Make sure hal adapter loads the correct symbol.
   if (module != &HAL_MODULE_INFO_SYM.common) {
     LOGF(ERROR) << "Invalid module " << module << " expected "
                 << &HAL_MODULE_INFO_SYM.common;
     return -EINVAL;
   }

   int id;
   if (!base::StringToInt(name, &id)) {
     LOGF(ERROR) << "Invalid camera name " << name;
     return -EINVAL;
   }
   return CameraHal::GetInstance().OpenDevice(id, module, device, client_type);
 }

 int get_camera_info_ext(int id,
                         struct camera_info* info,
                         ClientType client_type) {
   return CameraHal::GetInstance().GetCameraInfo(id, info, client_type);
 }

 int camera_device_open(const hw_module_t* module,
                        const char* name,
                        hw_device_t** device) {
   return camera_device_open_ext(module, name, device, ClientType::kChrome);
 }

 int get_number_of_cameras() {
   return CameraHal::GetInstance().GetNumberOfCameras();
 }

 int get_camera_info(int id, struct camera_info* info) {
   return get_camera_info_ext(id, info, ClientType::kChrome);
 }

 int set_callbacks(const camera_module_callbacks_t* callbacks) {
   return CameraHal::GetInstance().SetCallbacks(callbacks);
 }

 int init() {
   return CameraHal::GetInstance().Init();
 }

 void set_up(CameraMojoChannelManagerToken* token) {
   CameraHal::GetInstance().SetUp(token);
 }

 void tear_down() {
   CameraHal::GetInstance().TearDown();
 }

 void set_privacy_switch_callback(PrivacySwitchStateChangeCallback callback) {
   CameraHal::GetInstance().SetPrivacySwitchCallback(callback);
 }

 int open_legacy(const struct hw_module_t* module,
                 const char* id,
                 uint32_t halVersion,
                 struct hw_device_t** device) {
   return -ENOSYS;
 }

 int set_torch_mode(const char* camera_id, bool enabled) {
   return -ENOSYS;
 }

 }  // namespace

 CameraHal::CameraHal() {
   // The constructor is first called by set_up which is not on the same
   // sequence as the other methods this class is run on.
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }

 CameraHal::~CameraHal() = default;

 CameraHal& CameraHal::GetInstance() {
   // Leak the static camera HAL here, since it has a non-trivial destructor
   // (from ReloadableConfigFile -> base::FilePathWatcher).
   static base::NoDestructor<CameraHal> camera_hal;
   return *camera_hal;
 }

 int CameraHal::GetNumberOfCameras() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   return 0;
 }

 int CameraHal::SetCallbacks(const camera_module_callbacks_t* callbacks) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   callbacks_ = callbacks;
   ApplySpec();

   return 0;
 }

 int CameraHal::Init() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   task_runner_ = base::SequencedTaskRunner::GetCurrentDefault();
   config_file_ = std::make_unique<ReloadableConfigFile>(
       ReloadableConfigFile::Options{base::FilePath(kDefaultFakeHalSpecFile),
                                     base::FilePath(kOverrideFakeHalSpecFile)});
   config_file_->SetCallback(
       base::BindRepeating(&CameraHal::OnSpecUpdated, base::Unretained(this)));

   return 0;
 }

 void CameraHal::SetUp(CameraMojoChannelManagerToken* token) {
   mojo_manager_token_ = token;
 }

 void CameraHal::TearDown() {}

 void CameraHal::SetPrivacySwitchCallback(
     PrivacySwitchStateChangeCallback callback) {}

 int CameraHal::OpenDevice(int id,
                           const hw_module_t* module,
                           hw_device_t** hw_device,
                           ClientType client_type) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   VLOGFID(1, id);

   if (!IsCameraIdValid(id)) {
     LOGF(ERROR) << "Camera ID " << id << " is invalid";
     return -ENODEV;
   }

   auto it = std::find_if(hal_spec_.cameras.begin(), hal_spec_.cameras.end(),
                          [id](const auto& spec) { return spec.id == id; });
   CHECK(it != hal_spec_.cameras.end());

   cameras_[id] = std::make_unique<CameraClient>(
       id, static_metadata_[id], request_template_[id], module, hw_device, *it);

   int ret = cameras_[id]->OpenDevice();
   if (ret != 0) {
     cameras_.erase(id);
     return -ENODEV;
   }

   return 0;
 }

 bool CameraHal::IsCameraIdValid(int id) {
   return base::Contains(hal_spec_.cameras, id,
                         [](const auto& spec) { return spec.id; });
 }

 int CameraHal::GetCameraInfo(int id,
                              struct camera_info* info,
                              ClientType client_type) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   VLOGFID(1, id);

   if (!IsCameraIdValid(id)) {
     LOGF(ERROR) << "Camera ID " << id << " is invalid";
     return -EINVAL;
   }

   info->facing = CAMERA_FACING_EXTERNAL;
   info->orientation = 0;
   info->device_version = CAMERA_DEVICE_API_VERSION_3_5;
   info->static_camera_characteristics = static_metadata_[id].getAndLock();
   info->resource_cost = 0;
   info->conflicting_devices = nullptr;
   info->conflicting_devices_length = 0;
   return 0;
 }

 void CameraHal::OnSpecUpdated(const base::Value::Dict& json_values) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   auto hal_spec = ParseHalSpecFromJsonValue(json_values);
   if (!hal_spec.has_value()) {
     LOGF(WARNING) << "config file is not formatted correctly, ignored.";
     return;
   }

   hal_spec_ = hal_spec.value();
   ApplySpec();
 }

 bool CameraHal::SetUpCamera(int id, const CameraSpec& spec) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   android::CameraMetadata static_metadata, request_template;

   if (!FillDefaultMetadata(&static_metadata, &request_template, spec)) {
     return false;
   }

   static_metadata_[id] = std::move(static_metadata);
   request_template_[id] = std::move(request_template);

   return true;
 }

 void CameraHal::TearDownCamera(int id) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   static_metadata_.erase(id);
   request_template_.erase(id);
 }

 void CameraHal::NotifyCameraConnected(int id, bool connected) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(callbacks_ != nullptr);

   callbacks_->camera_device_status_change(
       callbacks_, id,
       connected ? CAMERA_DEVICE_STATUS_PRESENT
                 : CAMERA_DEVICE_STATUS_NOT_PRESENT);
 }

 void CameraHal::ApplySpec() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   if (callbacks_ == nullptr) {
     // Spec will be applied when callback is set.
     return;
   }

   bool should_apply_delayed_spec = false;
   auto new_applied_spec = hal_spec_;

   for (const auto& old_camera_spec : applied_hal_spec_.cameras) {
     int id = old_camera_spec.id;
     auto it = std::find_if(new_applied_spec.cameras.begin(),
                            new_applied_spec.cameras.end(),
                            [&](const auto& spec) { return spec.id == id; });
     // TODO(pihsun): Might need to close the camera if some currently opened
     // camera is removed in spec.
     if (it == new_applied_spec.cameras.end()) {
       // Camera entry removed.
       if (old_camera_spec.connected) {
         VLOGF(1) << "Removing camera " << id;
         NotifyCameraConnected(id, false);
         TearDownCamera(id);
       }
     } else {
       if (it->connected != old_camera_spec.connected) {
         // Device connected state changed.
         VLOGF(1) << "Camera " << id << " connected state changed "
                  << old_camera_spec.connected << "->" << it->connected;
         NotifyCameraConnected(id, it->connected);
       } else if (it->connected) {
         bool should_reconnect = false;
         if (it->supported_formats != old_camera_spec.supported_formats) {
           VLOGF(1) << "Camera " << id << " supported formats changed";
           NotifyCameraConnected(id, false);
           TearDownCamera(id);

           // Supported format changes change static metadata, so we need to
           // regenerate static metadata here.
           if (!SetUpCamera(id, *it)) {
             // TODO(pihsun): Better handle error? We should at least remove the
             // entry from the new spec.
             LOGF(WARNING) << "Error when setting up camera id " << id;
             continue;
           }
           should_reconnect = true;
         } else if (it->frames != old_camera_spec.frames) {
           // TODO(pihsun): For frames spec change it's possible to just start
           // returning new frames in the CameraClient instead of simulating
           // unplug / plug the camera.
           VLOGF(1) << "Camera " << id << " frames spec changed";
           NotifyCameraConnected(id, false);
           should_reconnect = true;
         }
         if (should_reconnect) {
           should_apply_delayed_spec = true;
           it->connected = false;
         }
       }
     }
   }
   for (const auto& camera_spec : new_applied_spec.cameras) {
     int id = camera_spec.id;
     if (std::none_of(applied_hal_spec_.cameras.begin(),
                      applied_hal_spec_.cameras.end(),
                      [&](const auto& spec) { return spec.id == id; })) {
       // New device.
       VLOGF(1) << "Adding camera " << id;
       if (!SetUpCamera(id, camera_spec)) {
         // TODO(pihsun): Better handle error? We should at least remove the
         // entry from the new spec.
         LOGF(WARNING) << "Error when setting up camera id " << id;
         continue;
       }
       NotifyCameraConnected(id, camera_spec.connected);
     }
   }

   applied_hal_spec_ = new_applied_spec;

   // TODO(b:261682032): This is for workaround that fake HAL plugging /
   // unplugging camera too quickly will cause issue in Chrome.
   if (should_apply_delayed_spec) {
     apply_spec_timer_.Start(FROM_HERE, kReconnectDelay, this,
                             &CameraHal::ApplySpec);
   }
 }

 void CameraHal::CloseDevice(int id) {
   VLOGFID(1, id);
   DCHECK(task_runner_);
   // The CameraHal is Singleton with NoDestructor so base::Unretained(this)
   // will always be valid.
   // Most of the work, like stopping the request handler thread, is done in
   // CameraClient::CloseDevice, and this only removes the CameraClient from the
   // CameraHal.
   task_runner_->PostTask(FROM_HERE,
                          base::BindOnce(&CameraHal::CloseDeviceOnHalThread,
                                         base::Unretained(this), id));
 }

 void CameraHal::CloseDeviceOnHalThread(int id) {
   VLOGFID(1, id);
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   cameras_.erase(id);
 }

 int camera_device_close(struct hw_device_t* hw_device) {
   camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(hw_device);
   CameraClient* cam = static_cast<CameraClient*>(cam_dev->priv);
   if (!cam) {
     LOGF(ERROR) << "Camera device is NULL";
     return -EIO;
   }
   cam_dev->priv = nullptr;
   int ret = cam->CloseDevice();
   CameraHal::GetInstance().CloseDevice(cam->GetId());
   return ret;
 }

 }  // namespace cros

 static hw_module_methods_t gCameraModuleMethods = {
     .open = cros::camera_device_open};

 camera_module_t HAL_MODULE_INFO_SYM CROS_CAMERA_EXPORT = {
     .common = {.tag = HARDWARE_MODULE_TAG,
                .module_api_version = CAMERA_MODULE_API_VERSION_2_4,
                .hal_api_version = HARDWARE_HAL_API_VERSION,
                .id = CAMERA_HARDWARE_MODULE_ID,
                // TODO(pihsun): Extract the module name to a constant if more
                // tests needs to have special case for fake HAL.
                .name = "Fake Camera HAL",
                .author = "The ChromiumOS Authors",
                .methods = &gCameraModuleMethods,
                .dso = nullptr,
                .reserved = {}},
     .get_number_of_cameras = cros::get_number_of_cameras,
     .get_camera_info = cros::get_camera_info,
     .set_callbacks = cros::set_callbacks,
     // TODO(pihsun): Implement faking vendor tags.
     .get_vendor_tag_ops = nullptr,
     .open_legacy = cros::open_legacy,
     .set_torch_mode = cros::set_torch_mode,
     .init = cros::init,
     .reserved = {}};

 cros::cros_camera_hal_t CROS_CAMERA_HAL_INFO_SYM CROS_CAMERA_EXPORT = {
     .set_up = cros::set_up,
     .tear_down = cros::tear_down,
     .set_privacy_switch_callback = cros::set_privacy_switch_callback,
     .camera_device_open_ext = cros::camera_device_open_ext,
     .get_camera_info_ext = cros::get_camera_info_ext};
	/* Copyright 2022 The ChromiumOS Authors
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "hal/fake/camera_hal.h"

	#include <algorithm>
	#include <memory>
	#include <utility>

	#include <base/containers/contains.h>
	#include <base/no_destructor.h>
	#include <base/strings/string_number_conversions.h>
	#include <base/task/sequenced_task_runner.h>

	#include "cros-camera/common.h"
	#include "cros-camera/cros_camera_hal.h"

	#include "hal/fake/metadata_handler.h"

	namespace cros {

	namespace {
	// The default fake hal spec file. The file should contain a JSON that is
	// parsed to HalSpec struct.
	constexpr const char kDefaultFakeHalSpecFile[] = "/etc/camera/fake_hal.json";
	constexpr const char kOverrideFakeHalSpecFile[] = "/run/camera/fake_hal.json";

	// This is the sleep time (0.3s) between reporting disconnect and connect event
	// to upper layer, to avoid race condition in Chrome.
	// TODO(b:261682032): Check if the time can be lower, and/or fix the issue in
	// Chrome so this is not needed.
	constexpr const base::TimeDelta kReconnectDelay = base::Milliseconds(300);

	int camera_device_open_ext(const hw_module_t* module,
	const char* name,
	hw_device_t** device,
	ClientType client_type) {
	// Make sure hal adapter loads the correct symbol.
	if (module != &HAL_MODULE_INFO_SYM.common) {
	LOGF(ERROR) << "Invalid module " << module << " expected "
	<< &HAL_MODULE_INFO_SYM.common;
	return -EINVAL;
	}

	int id;
	if (!base::StringToInt(name, &id)) {
	LOGF(ERROR) << "Invalid camera name " << name;
	return -EINVAL;
	}
	return CameraHal::GetInstance().OpenDevice(id, module, device, client_type);
	}

	int get_camera_info_ext(int id,
	struct camera_info* info,
	ClientType client_type) {
	return CameraHal::GetInstance().GetCameraInfo(id, info, client_type);
	}

	int camera_device_open(const hw_module_t* module,
	const char* name,
	hw_device_t** device) {
	return camera_device_open_ext(module, name, device, ClientType::kChrome);
	}

	int get_number_of_cameras() {
	return CameraHal::GetInstance().GetNumberOfCameras();
	}

	int get_camera_info(int id, struct camera_info* info) {
	return get_camera_info_ext(id, info, ClientType::kChrome);
	}

	int set_callbacks(const camera_module_callbacks_t* callbacks) {
	return CameraHal::GetInstance().SetCallbacks(callbacks);
	}

	int init() {
	return CameraHal::GetInstance().Init();
	}

	void set_up(CameraMojoChannelManagerToken* token) {
	CameraHal::GetInstance().SetUp(token);
	}

	void tear_down() {
	CameraHal::GetInstance().TearDown();
	}

	void set_privacy_switch_callback(PrivacySwitchStateChangeCallback callback) {
	CameraHal::GetInstance().SetPrivacySwitchCallback(callback);
	}

	int open_legacy(const struct hw_module_t* module,
	const char* id,
	uint32_t halVersion,
	struct hw_device_t** device) {
	return -ENOSYS;
	}

	int set_torch_mode(const char* camera_id, bool enabled) {
	return -ENOSYS;
	}

	} // namespace

	CameraHal::CameraHal() {
	// The constructor is first called by set_up which is not on the same
	// sequence as the other methods this class is run on.
	DETACH_FROM_SEQUENCE(sequence_checker_);
	}

	CameraHal::~CameraHal() = default;

	CameraHal& CameraHal::GetInstance() {
	// Leak the static camera HAL here, since it has a non-trivial destructor
	// (from ReloadableConfigFile -> base::FilePathWatcher).
	static base::NoDestructor<CameraHal> camera_hal;
	return *camera_hal;
	}

	int CameraHal::GetNumberOfCameras() const {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	return 0;
	}

	int CameraHal::SetCallbacks(const camera_module_callbacks_t* callbacks) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	callbacks_ = callbacks;
	ApplySpec();

	return 0;
	}

	int CameraHal::Init() {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	task_runner_ = base::SequencedTaskRunner::GetCurrentDefault();
	config_file_ = std::make_unique<ReloadableConfigFile>(
	ReloadableConfigFile::Options{base::FilePath(kDefaultFakeHalSpecFile),
	base::FilePath(kOverrideFakeHalSpecFile)});
	config_file_->SetCallback(
	base::BindRepeating(&CameraHal::OnSpecUpdated, base::Unretained(this)));

	return 0;
	}

	void CameraHal::SetUp(CameraMojoChannelManagerToken* token) {
	mojo_manager_token_ = token;
	}

	void CameraHal::TearDown() {}

	void CameraHal::SetPrivacySwitchCallback(
	PrivacySwitchStateChangeCallback callback) {}

	int CameraHal::OpenDevice(int id,
	const hw_module_t* module,
	hw_device_t** hw_device,
	ClientType client_type) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	VLOGFID(1, id);

	if (!IsCameraIdValid(id)) {
	LOGF(ERROR) << "Camera ID " << id << " is invalid";
	return -ENODEV;
	}

	auto it = std::find_if(hal_spec_.cameras.begin(), hal_spec_.cameras.end(),
	[id](const auto& spec) { return spec.id == id; });
	CHECK(it != hal_spec_.cameras.end());

	cameras_[id] = std::make_unique<CameraClient>(
	id, static_metadata_[id], request_template_[id], module, hw_device, *it);

	int ret = cameras_[id]->OpenDevice();
	if (ret != 0) {
	cameras_.erase(id);
	return -ENODEV;
	}

	return 0;
	}

	bool CameraHal::IsCameraIdValid(int id) {
	return base::Contains(hal_spec_.cameras, id,
	[](const auto& spec) { return spec.id; });
	}

	int CameraHal::GetCameraInfo(int id,
	struct camera_info* info,
	ClientType client_type) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	VLOGFID(1, id);

	if (!IsCameraIdValid(id)) {
	LOGF(ERROR) << "Camera ID " << id << " is invalid";
	return -EINVAL;
	}

	info->facing = CAMERA_FACING_EXTERNAL;
	info->orientation = 0;
	info->device_version = CAMERA_DEVICE_API_VERSION_3_5;
	info->static_camera_characteristics = static_metadata_[id].getAndLock();
	info->resource_cost = 0;
	info->conflicting_devices = nullptr;
	info->conflicting_devices_length = 0;
	return 0;
	}

	void CameraHal::OnSpecUpdated(const base::Value::Dict& json_values) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	auto hal_spec = ParseHalSpecFromJsonValue(json_values);
	if (!hal_spec.has_value()) {
	LOGF(WARNING) << "config file is not formatted correctly, ignored.";
	return;
	}

	hal_spec_ = hal_spec.value();
	ApplySpec();
	}

	bool CameraHal::SetUpCamera(int id, const CameraSpec& spec) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	android::CameraMetadata static_metadata, request_template;

	if (!FillDefaultMetadata(&static_metadata, &request_template, spec)) {
	return false;
	}

	static_metadata_[id] = std::move(static_metadata);
	request_template_[id] = std::move(request_template);

	return true;
	}

	void CameraHal::TearDownCamera(int id) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	static_metadata_.erase(id);
	request_template_.erase(id);
	}

	void CameraHal::NotifyCameraConnected(int id, bool connected) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	DCHECK(callbacks_ != nullptr);

	callbacks_->camera_device_status_change(
	callbacks_, id,
	connected ? CAMERA_DEVICE_STATUS_PRESENT
	: CAMERA_DEVICE_STATUS_NOT_PRESENT);
	}

	void CameraHal::ApplySpec() {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	if (callbacks_ == nullptr) {
	// Spec will be applied when callback is set.
	return;
	}

	bool should_apply_delayed_spec = false;
	auto new_applied_spec = hal_spec_;

	for (const auto& old_camera_spec : applied_hal_spec_.cameras) {
	int id = old_camera_spec.id;
	auto it = std::find_if(new_applied_spec.cameras.begin(),
	new_applied_spec.cameras.end(),
	[&](const auto& spec) { return spec.id == id; });
	// TODO(pihsun): Might need to close the camera if some currently opened
	// camera is removed in spec.
	if (it == new_applied_spec.cameras.end()) {
	// Camera entry removed.
	if (old_camera_spec.connected) {
	VLOGF(1) << "Removing camera " << id;
	NotifyCameraConnected(id, false);
	TearDownCamera(id);
	}
	} else {
	if (it->connected != old_camera_spec.connected) {
	// Device connected state changed.
	VLOGF(1) << "Camera " << id << " connected state changed "
	<< old_camera_spec.connected << "->" << it->connected;
	NotifyCameraConnected(id, it->connected);
	} else if (it->connected) {
	bool should_reconnect = false;
	if (it->supported_formats != old_camera_spec.supported_formats) {
	VLOGF(1) << "Camera " << id << " supported formats changed";
	NotifyCameraConnected(id, false);
	TearDownCamera(id);

	// Supported format changes change static metadata, so we need to
	// regenerate static metadata here.
	if (!SetUpCamera(id, *it)) {
	// TODO(pihsun): Better handle error? We should at least remove the
	// entry from the new spec.
	LOGF(WARNING) << "Error when setting up camera id " << id;
	continue;
	}
	should_reconnect = true;
	} else if (it->frames != old_camera_spec.frames) {
	// TODO(pihsun): For frames spec change it's possible to just start
	// returning new frames in the CameraClient instead of simulating
	// unplug / plug the camera.
	VLOGF(1) << "Camera " << id << " frames spec changed";
	NotifyCameraConnected(id, false);
	should_reconnect = true;
	}
	if (should_reconnect) {
	should_apply_delayed_spec = true;
	it->connected = false;
	}
	}
	}
	}
	for (const auto& camera_spec : new_applied_spec.cameras) {
	int id = camera_spec.id;
	if (std::none_of(applied_hal_spec_.cameras.begin(),
	applied_hal_spec_.cameras.end(),
	[&](const auto& spec) { return spec.id == id; })) {
	// New device.
	VLOGF(1) << "Adding camera " << id;
	if (!SetUpCamera(id, camera_spec)) {
	// TODO(pihsun): Better handle error? We should at least remove the
	// entry from the new spec.
	LOGF(WARNING) << "Error when setting up camera id " << id;
	continue;
	}
	NotifyCameraConnected(id, camera_spec.connected);
	}
	}

	applied_hal_spec_ = new_applied_spec;

	// TODO(b:261682032): This is for workaround that fake HAL plugging /
	// unplugging camera too quickly will cause issue in Chrome.
	if (should_apply_delayed_spec) {
	apply_spec_timer_.Start(FROM_HERE, kReconnectDelay, this,
	&CameraHal::ApplySpec);
	}
	}

	void CameraHal::CloseDevice(int id) {
	VLOGFID(1, id);
	DCHECK(task_runner_);
	// The CameraHal is Singleton with NoDestructor so base::Unretained(this)
	// will always be valid.
	// Most of the work, like stopping the request handler thread, is done in
	// CameraClient::CloseDevice, and this only removes the CameraClient from the
	// CameraHal.
	task_runner_->PostTask(FROM_HERE,
	base::BindOnce(&CameraHal::CloseDeviceOnHalThread,
	base::Unretained(this), id));
	}

	void CameraHal::CloseDeviceOnHalThread(int id) {
	VLOGFID(1, id);
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	cameras_.erase(id);
	}

	int camera_device_close(struct hw_device_t* hw_device) {
	camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(hw_device);
	CameraClient* cam = static_cast<CameraClient*>(cam_dev->priv);
	if (!cam) {
	LOGF(ERROR) << "Camera device is NULL";
	return -EIO;
	}
	cam_dev->priv = nullptr;
	int ret = cam->CloseDevice();
	CameraHal::GetInstance().CloseDevice(cam->GetId());
	return ret;
	}

	} // namespace cros

	static hw_module_methods_t gCameraModuleMethods = {
	.open = cros::camera_device_open};

	camera_module_t HAL_MODULE_INFO_SYM CROS_CAMERA_EXPORT = {
	.common = {.tag = HARDWARE_MODULE_TAG,
	.module_api_version = CAMERA_MODULE_API_VERSION_2_4,
	.hal_api_version = HARDWARE_HAL_API_VERSION,
	.id = CAMERA_HARDWARE_MODULE_ID,
	// TODO(pihsun): Extract the module name to a constant if more
	// tests needs to have special case for fake HAL.
	.name = "Fake Camera HAL",
	.author = "The ChromiumOS Authors",
	.methods = &gCameraModuleMethods,
	.dso = nullptr,
	.reserved = {}},
	.get_number_of_cameras = cros::get_number_of_cameras,
	.get_camera_info = cros::get_camera_info,
	.set_callbacks = cros::set_callbacks,
	// TODO(pihsun): Implement faking vendor tags.
	.get_vendor_tag_ops = nullptr,
	.open_legacy = cros::open_legacy,
	.set_torch_mode = cros::set_torch_mode,
	.init = cros::init,
	.reserved = {}};

	cros::cros_camera_hal_t CROS_CAMERA_HAL_INFO_SYM CROS_CAMERA_EXPORT = {
	.set_up = cros::set_up,
	.tear_down = cros::tear_down,
	.set_privacy_switch_callback = cros::set_privacy_switch_callback,
	.camera_device_open_ext = cros::camera_device_open_ext,
	.get_camera_info_ext = cros::get_camera_info_ext};