diff --git a/src/android/camera_hal_manager.cpp b/src/android/camera_hal_manager.cpp index 3a744af..e851185 100644 --- a/src/android/camera_hal_manager.cpp +++ b/src/android/camera_hal_manager.cpp @@ -8,6 +8,7 @@ #include "camera_hal_manager.h" #include +#include #include "libcamera/internal/log.h" @@ -35,6 +36,7 @@ CameraHalManager::CameraHalManager() CameraHalManager::~CameraHalManager() { cameras_.clear(); + camerasMap_.clear(); if (cameraManager_) { cameraManager_->stop(); @@ -47,6 +49,13 @@ int CameraHalManager::init() { cameraManager_ = new CameraManager(); + /* Support camera hotplug. */ + cameraManager_->cameraAdded.connect(this, &CameraHalManager::cameraAdded); + cameraManager_->cameraRemoved.connect(this, &CameraHalManager::cameraRemoved); + + internalCameras_ = 0; + externalCameras_ = 1000; + int ret = cameraManager_->start(); if (ret) { LOG(HAL, Error) << "Failed to start camera manager: " @@ -56,35 +65,22 @@ int CameraHalManager::init() return ret; } - /* - * For each Camera registered in the system, a CameraDevice - * gets created here to wraps a libcamera Camera instance. - * - * \todo Support camera hotplug. - */ - unsigned int index = 0; - for (auto &cam : cameraManager_->cameras()) { - std::shared_ptr camera = CameraDevice::create(index, cam); - ret = camera->initialize(); - if (ret) - continue; - - cameras_.emplace_back(std::move(camera)); - ++index; - } - return 0; } CameraDevice *CameraHalManager::open(unsigned int id, const hw_module_t *hardwareModule) { - if (id >= numCameras()) { + MutexLocker locker(mutex_); + + auto iter = cameraIterFromId(id); + if (iter == cameras_.end()) { LOG(HAL, Error) << "Invalid camera id '" << id << "'"; return nullptr; } - CameraDevice *camera = cameras_[id].get(); + CameraDevice *camera = iter->get(); + if (camera->open(hardwareModule)) return nullptr; @@ -93,9 +89,114 @@ CameraDevice *CameraHalManager::open(unsigned int id, return camera; } +void CameraHalManager::cameraAdded(std::shared_ptr cam) +{ + unsigned int id; + bool isCameraExternal = false; + bool isCameraNew = false; + + MutexLocker locker(mutex_); + + /* + * Each camera is assigned a unique integer ID when it is seen for the + * first time. If the camera has been seen before, the previous ID is + * re-used and the camera is marked as CAMERA_DEVICE_STATUS_PRESENT + * subsequently. + * + * IDs starts from '0' for internal cameras and '1000' for external + * cameras. + */ + auto iter = camerasMap_.find(cam->id()); + if (iter != camerasMap_.end()) { + id = iter->second; + } else { + isCameraNew = true; + + /* + * Now check if this is an external camera and assign + * its id accordingly. + */ + const ControlList &properties = cam->properties(); + if (properties.contains(properties::Location) && + properties.get(properties::Location) == + properties::CameraLocationExternal) { + isCameraExternal = true; + id = externalCameras_; + } else { + id = internalCameras_; + } + } + + /* + * For each Camera registered in the system, a CameraDevice + * gets created here to wraps a libcamera Camera instance. + */ + std::shared_ptr camera = CameraDevice::create(id, std::move(cam)); + int ret = camera->initialize(); + if (ret) { + LOG(HAL, Error) << "Failed to initialize camera: " << cam->id(); + return; + } + + if (isCameraNew) { + camerasMap_.emplace(cam->id(), id); + + if (isCameraExternal) + externalCameras_++; + else + internalCameras_++; + } + + cameras_.emplace_back(std::move(camera)); + + if (callbacks_) + callbacks_->camera_device_status_change(callbacks_, id, + CAMERA_DEVICE_STATUS_PRESENT); + + LOG(HAL, Debug) << "Camera ID: " << id << " added successfully."; +} + +void CameraHalManager::cameraRemoved(std::shared_ptr cam) +{ + MutexLocker locker(mutex_); + + auto iter = cameraIterFromCamera(cam.get()); + if (iter == cameras_.end()) + return; + + unsigned int id = (*iter)->id(); + callbacks_->camera_device_status_change(callbacks_, id, + CAMERA_DEVICE_STATUS_NOT_PRESENT); + + /* + * \todo Check if the camera is already open and running. + * Inform the framework about it's absence before deleting it's + * reference here. + */ + cameras_.erase(iter); + + LOG(HAL, Debug) << "Camera ID: " << id << " removed successfully."; +} + +CameraHalManager::cameraDeviceIter CameraHalManager::cameraIterFromId(unsigned int id) +{ + return std::find_if(cameras_.begin(), cameras_.end(), + [id](std::shared_ptr &camera) { + return camera->id() == id; + }); +} + +CameraHalManager::cameraDeviceIter CameraHalManager::cameraIterFromCamera(Camera *cam) +{ + return std::find_if(cameras_.begin(), cameras_.end(), + [cam](std::shared_ptr &camera) { + return cam == camera->camera(); + }); +} + unsigned int CameraHalManager::numCameras() const { - return cameraManager_->cameras().size(); + return internalCameras_; } int CameraHalManager::getCameraInfo(unsigned int id, struct camera_info *info) @@ -103,12 +204,15 @@ int CameraHalManager::getCameraInfo(unsigned int id, struct camera_info *info) if (!info) return -EINVAL; - if (id >= numCameras()) { + MutexLocker locker(mutex_); + + auto iter = cameraIterFromId(id); + if (iter == cameras_.end()) { LOG(HAL, Error) << "Invalid camera id '" << id << "'"; return -EINVAL; } - CameraDevice *camera = cameras_[id].get(); + CameraDevice *camera = iter->get(); info->facing = camera->facing(); info->orientation = camera->orientation(); @@ -124,4 +228,30 @@ int CameraHalManager::getCameraInfo(unsigned int id, struct camera_info *info) void CameraHalManager::setCallbacks(const camera_module_callbacks_t *callbacks) { callbacks_ = callbacks; + + MutexLocker locker(mutex_); + + /* + * Some external cameras may have been identified before the + * callbacks_ were enabled. Iterate any existing external + * cameras and mark them as CAMERA_DEVICE_STATUS_PRESENT + * explicitly. + * + * Internal cameras are already assumed to be present at module + * load time by the android framework. + */ + for (auto &cam : cameraManager_->cameras()) { + auto iter = camerasMap_.find(cam->id()); + if (iter == camerasMap_.end()) + continue; + + unsigned int id = iter->second; + const ControlList &properties = cam->properties(); + if (properties.contains(properties::Location) && + properties.get(properties::Location) & + properties::CameraLocationExternal) { + callbacks_->camera_device_status_change(callbacks_, id, + CAMERA_DEVICE_STATUS_PRESENT); + } + } } diff --git a/src/android/camera_hal_manager.h b/src/android/camera_hal_manager.h index 3e34d63..f8adade 100644 --- a/src/android/camera_hal_manager.h +++ b/src/android/camera_hal_manager.h @@ -7,6 +7,8 @@ #ifndef __ANDROID_CAMERA_MANAGER_H__ #define __ANDROID_CAMERA_MANAGER_H__ +#include +#include #include #include @@ -18,12 +20,17 @@ class CameraDevice; +using Mutex = std::mutex; +using MutexLocker = std::unique_lock; + class CameraHalManager { public: CameraHalManager(); ~CameraHalManager(); + using cameraDeviceIter = std::vector>::iterator; + int init(); CameraDevice *open(unsigned int id, const hw_module_t *module); @@ -33,10 +40,21 @@ public: void setCallbacks(const camera_module_callbacks_t *callbacks); private: + void cameraAdded(std::shared_ptr cam); + void cameraRemoved(std::shared_ptr cam); + + cameraDeviceIter cameraIterFromId(unsigned int id); + cameraDeviceIter cameraIterFromCamera(libcamera::Camera *cam); + libcamera::CameraManager *cameraManager_; const camera_module_callbacks_t *callbacks_; std::vector> cameras_; + std::map camerasMap_; + Mutex mutex_; + + unsigned int internalCameras_; + unsigned int externalCameras_; }; #endif /* __ANDROID_CAMERA_MANAGER_H__ */