cmvr-es/cmvr-es/devices/camera/camera_factory.h

#ifndef CMVR_ES_CAMERA_FACTORY_H
#define CMVR_ES_CAMERA_FACTORY_H

#include <memory>
#include <stdexcept>
#include <string>

#include "cmvr/config/camera_config/camera_config.pb.h"
#include "common/base/logging/logger.h"
#include "devices/camera/abstract_camera.h"
#include "devices/camera/mujoco_camera/include/mujoco_camera.h"
#include "devices/camera/hikvision_camera/include/hikvision_camera.h"
#include "devices/camera/realsense_camera/include/realsense_camera.h"
#include "devices/camera/uvc_camera/include/uvc_camera.h"

namespace cmvr::device {

class CameraFactory {
public:
    static std::shared_ptr<AbstractCamera> create(const config::CameraDeviceConfig& cfg)
    {
        try {
            if (cfg.id().empty()) {
                const std::string error = "[CameraFactory]: Camera id is empty";
                CMVR_LOG(ERROR) << error;
                return nullptr;
            }

            switch (cfg.backend_case()) {
            case config::CameraDeviceConfig::kUvc:
                return std::make_shared<UVCCamera>(backendWithId_(cfg.id(), cfg.uvc()));

            case config::CameraDeviceConfig::kRealsense:
                return std::make_shared<RealsenseCamera>(
                    backendWithId_(cfg.id(), cfg.realsense()));

            case config::CameraDeviceConfig::kMechmind:
            {
                const std::string error =
                    "[CameraFactory]: MechMind camera is not enabled in this build: " + cfg.id();
                CMVR_LOG(ERROR) << error;
                return nullptr;
            }

            case config::CameraDeviceConfig::kHikvision:
                return std::make_shared<HikvisionCamera>(
                    backendWithId_(cfg.id(), cfg.hikvision()));

            case config::CameraDeviceConfig::kMujoco:
                return std::make_shared<MujocoCamera>(
                    backendWithId_(cfg.id(), cfg.mujoco()));

            case config::CameraDeviceConfig::BACKEND_NOT_SET:
            default:
            {
                const std::string error =
                    "[CameraFactory]: Camera backend is not configured: " + cfg.id();
                CMVR_LOG(ERROR) << error;
                return nullptr;
            }
            }
        } catch (const std::exception& e) {
            CMVR_LOG(ERROR) << "[CameraFactory]: Failed to create camera " << cfg.id()
                            << ": " << e.what();
            return nullptr;
        } catch (...) {
            CMVR_LOG(ERROR) << "[CameraFactory]: Failed to create camera " << cfg.id()
                            << ": unknown exception";
            return nullptr;
        }
    }

private:
    template <typename BackendConfig>
    static BackendConfig backendWithId_(const std::string& id, const BackendConfig& source)
    {
        if (!source.id().empty() && source.id() != id) {
            const std::string error = "[CameraFactory]: Camera id does not match backend id: " + id;
            CMVR_LOG(ERROR) << error;
            return BackendConfig{};
        }
        BackendConfig backend = source;
        backend.set_id(id);
        return backend;
    }
};

} // namespace cmvr::device

#endif // CMVR_ES_CAMERA_FACTORY_H