OB2Device.hpp

浏览该文件的文档.

#pragma once
 
#include "OB2Types.hpp"
#include "OB2Camera.hpp"
#include "OB2IMU.hpp"
 
extern "C" {
#include "h/ob2device.h"
#include "h/ob2command.h"
}
 
#include <vector>
#include <memory>
 
namespace ob2 {
 
class device {
public:
    device(ob2_device_t &&device_handle) : m_device_handle(device_handle), m_capture_cb(nullptr), m_firmware_update_state_cb(nullptr) {
        VALIDATE_NOT_NULL(m_device_handle);
    }
 
    device(device &&dev) : m_device_handle(dev.m_device_handle) {
        VALIDATE_NOT_NULL(m_device_handle);
        dev.m_device_handle = nullptr;
    }
 
    virtual ~device() noexcept {
        ob2_status_t status;
        if(m_device_handle != nullptr) {
            ob2_device_close(m_device_handle, &status);
        }
    }
 
    virtual ob2_device_info_t get_info() {
        ob2_status_t status;
        auto         device_info = ob2_device_get_info(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return device_info;
    }
 
    virtual ob2_device_t get_handle() {
        return m_device_handle;
    }
 
public:
    virtual std::vector<ob2_camera_type_t> get_supported_camera_type_list() {
        ob2_status_t status;
        auto         count = ob2_device_get_supported_camera_count(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_camera_type_t> camera_list;
        for(uint32_t index = 0; index < count; index++) {
            auto camera_type = ob2_device_get_supported_camera_type(m_device_handle, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            camera_list.emplace_back(camera_type);
        }
        return camera_list;
    }
 
    virtual std::vector<ob2_camera_stream_profile_t> get_camera_stream_profile_list(ob2_camera_type_t camera_type) {
        ob2_status_t status;
        auto         count = ob2_device_get_camera_stream_profile_count(m_device_handle, camera_type, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_camera_stream_profile_t> profile_list;
        for(uint32_t index = 0; index < count; index++) {
            auto profile = ob2_device_get_camera_stream_profile(m_device_handle, camera_type, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            profile_list.emplace_back(std::move(profile));
        }
        return profile_list;
    }
 
    virtual ob2_camera_stream_profile_t get_default_camera_stream_profile(ob2_camera_type_t camera_type) {
        ob2_status_t status;
        auto         profile = ob2_device_get_camera_stream_profile(m_device_handle, camera_type, OB2_DEFAULT_STREAM_PROFILE, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return profile;
    }
 
    virtual std::vector<ob2_camera_stream_profile_t> get_alignable_camera_stream_profile_list(ob2_images_align_mode_t            align_mode,
                                                                                              const ob2_camera_stream_profile_t &target_camera_stream_profile) {
        ob2_status_t status;
 
        auto count = ob2_device_get_alignable_camera_stream_profile_count(m_device_handle, align_mode, target_camera_stream_profile, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_camera_stream_profile_t> profile_list;
        for(uint32_t index = 0; index < count; index++) {
            auto profile = ob2_device_get_alignable_camera_stream_profile(m_device_handle, align_mode, target_camera_stream_profile, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            profile_list.emplace_back(std::move(profile));
        }
        return profile_list;
    }
 
    virtual std::shared_ptr<cameras_config> create_cameras_config() {
        ob2_status_t status;
        auto         cameras_config_handle = ob2_device_create_cameras_config(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<cameras_config>(std::move(cameras_config_handle));
    }
 
    virtual void start_cameras(std::shared_ptr<cameras_config> cam_config) {
        ob2_status_t         status;
        ob2_cameras_config_t cameras_config_handle = OB2_DEFAULT_CAMERAS_CONFIG;
        if(cam_config) {
            cameras_config_handle = cam_config->get_handle();
        }
        ob2_device_start_cameras(m_device_handle, cameras_config_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void start_cameras_with_callback(std::shared_ptr<cameras_config> cam_config, capture_cb cb) {
        ob2_status_t         status;
        ob2_cameras_config_t cameras_config_handle = OB2_DEFAULT_CAMERAS_CONFIG;
        if(cam_config) {
            cameras_config_handle = cam_config->get_handle();
        }
 
        m_capture_cb = cb;
 
        ob2_device_start_cameras_with_callback(m_device_handle, cameras_config_handle, &device::capture_callback, this, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void update_cameras_config(std::shared_ptr<cameras_config> cam_config) {
        ob2_status_t status;
        ob2_device_update_cameras_config(m_device_handle, cam_config->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void stop_cameras() {
        ob2_status_t status;
        ob2_device_stop_cameras(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_cameras_calibration_t get_cameras_calibration(std::shared_ptr<cameras_config> cam_config) {
        ob2_status_t status;
        auto         calibration = ob2_device_get_cameras_calibration(m_device_handle, cam_config->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return calibration;
    }
 
    virtual std::shared_ptr<capture> get_capture(int32_t timeout_msec) {
        ob2_status_t status;
        auto         capture_handle = ob2_device_get_capture(m_device_handle, timeout_msec, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        if(nullptr != capture_handle) {
            return std::make_shared<capture>(std::move(capture_handle));
        }
        return nullptr;
    }
 
public:
    virtual std::vector<ob2_imu_sensor_type_t> get_supported_imu_sensor_type_list() {
        ob2_status_t status;
        auto         count = ob2_device_get_supported_imu_sensor_count(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_imu_sensor_type_t> imu_sensor_list;
        for(uint32_t index = 0; index < count; index++) {
            auto sensor_type = ob2_device_get_supported_imu_sensor_type(m_device_handle, index, &status);
            imu_sensor_list.push_back(sensor_type);
        }
        return imu_sensor_list;
    }
 
    virtual std::vector<ob2_accel_stream_profile_t> get_accel_stream_profile_list() {
        ob2_status_t status;
        auto         count = ob2_device_get_accel_stream_profile_count(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_accel_stream_profile_t> profile_list;
        for(uint32_t index = 0; index < count; index++) {
            auto profile = ob2_device_get_accel_stream_profile(m_device_handle, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            profile_list.emplace_back(std::move(profile));
        }
        return profile_list;
    }
 
    virtual std::vector<ob2_gyro_stream_profile_t> get_gyro_stream_profile_list() {
        ob2_status_t status;
        auto         count = ob2_device_get_gyro_stream_profile_count(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_gyro_stream_profile_t> profile_list;
        for(uint32_t index = 0; index < count; index++) {
            auto profile = ob2_device_get_gyro_stream_profile(m_device_handle, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            profile_list.emplace_back(std::move(profile));
        }
        return profile_list;
    }
 
    virtual std::shared_ptr<imu_config> create_imu_config() {
        ob2_status_t status;
        auto         imu_config_handle = ob2_device_create_imu_config(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<imu_config>(std::move(imu_config_handle));
    }
 
    virtual void start_imu(std::shared_ptr<imu_config> imu_config) {
        ob2_status_t     status;
        ob2_imu_config_t imu_config_handle = OB2_DEFAULT_IMU_CONFIG;
        if(imu_config) {
            imu_config_handle = imu_config->get_handle();
        }
 
        ob2_device_start_imu(m_device_handle, imu_config_handle, &status);
 
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void start_imu_with_callback(std::shared_ptr<imu_config> imu_config, imu_sample_cb cb) {
        ob2_status_t     status;
        ob2_imu_config_t imu_config_handle = OB2_DEFAULT_IMU_CONFIG;
        if(imu_config) {
            imu_config_handle = imu_config->get_handle();
        }
 
        m_imu_sample_cb = cb;
 
        ob2_device_start_imu_with_callback(m_device_handle, imu_config_handle, &device::imu_sample_callback, this, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void stop_imu() {
        ob2_status_t status;
        ob2_device_stop_imu(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    std::shared_ptr<imu_sample> get_imu_sample(int32_t timeout_msec) {
        ob2_status_t status;
        auto         imu_sample_handle = ob2_device_get_imu_sample(m_device_handle, timeout_msec, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<imu_sample>(std::move(imu_sample_handle));
    }
 
    void update_imu_config(std::shared_ptr<imu_config> config) {
        ob2_status_t status;
        ob2_device_update_imu_config(m_device_handle, config->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
public:
    virtual void update_firmware(const char *firmware_file_path, firmware_update_state_cb callback, ob2_enable_ctrl_t enable_async_mode) {
        ob2_status_t status;
        ob2_device_update_firmware(m_device_handle, firmware_file_path, &device::firmware_update_state_callback, this, enable_async_mode, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void reboot() {
        ob2_status_t status;
        ob2_device_reboot(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void sync_clock_with_host() {
        ob2_status_t status;
        ob2_device_sync_clock_with_host(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
public:
    virtual std::vector<ob2_command_info_t> get_supported_command_info_list() {
        ob2_status_t status;
        auto         count = ob2_device_get_supported_command_count(m_device_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_command_info_t> command_info_list;
        for(uint32_t index = 0; index < count; index++) {
            auto command_info = ob2_device_get_supported_command_info(m_device_handle, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            command_info_list.emplace_back(std::move(command_info));
        }
 
        return command_info_list;
    }
 
    virtual ob2_command_info_t get_supported_command_info_by_id(ob2_command_id_t command_id) {
        ob2_status_t status;
        auto         command_info = ob2_device_get_supported_command_info_by_id(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return command_info;
    }
 
    virtual bool check_command_access_permission(ob2_command_id_t command_id, ob2_access_permission_t permission) {
        ob2_status_t status;
        auto         command_info = ob2_device_check_command_access_permission(m_device_handle, command_id, permission, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return command_info;
    }
 
    virtual bool get_bool_property_value(ob2_command_id_t command_id) {
        ob2_status_t status;
        bool         value = ob2_device_get_bool_property_value(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return value;
    }
 
    virtual void set_bool_property_value(ob2_command_id_t command_id, bool value) {
        ob2_status_t status;
        ob2_device_set_bool_property_value(m_device_handle, command_id, value, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual bool get_bool_property_default_value(ob2_command_id_t command_id) {
        ob2_status_t status;
        bool         def = ob2_device_get_bool_property_default_value(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return def;
    }
 
    virtual int get_int_property_value(ob2_command_id_t command_id) {
        ob2_status_t status;
        int          value = ob2_device_get_int_property_value(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return value;
    }
 
    virtual void set_int_property_value(ob2_command_id_t command_id, int value) {
        ob2_status_t status;
        ob2_device_set_int_property_value(m_device_handle, command_id, value, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_int_property_capability_t get_int_property_capability(ob2_command_id_t command_id) {
        ob2_status_t                  status;
        ob2_int_property_capability_t capability = ob2_device_get_int_property_capability(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return capability;
    }
 
    virtual float get_float_property_value(ob2_command_id_t command_id) {
        ob2_status_t status;
        float        value = ob2_device_get_float_property_value(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return value;
    }
 
    virtual void set_float_property_value(ob2_command_id_t command_id, float value) {
        ob2_status_t status;
        ob2_device_set_float_property_value(m_device_handle, command_id, value, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_float_property_capability_t get_float_property_capability(ob2_command_id_t command_id) {
        ob2_status_t                    status;
        ob2_float_property_capability_t capability = ob2_device_get_float_property_capability(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return capability;
    }
 
    virtual ob2_data_bundle_t *get_structured_data(ob2_command_id_t command_id) {
        ob2_status_t       status;
        ob2_data_bundle_t *data_bundle = ob2_device_get_structured_data(m_device_handle, command_id, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return data_bundle;
    }
 
    virtual void update_structured_data(ob2_command_id_t command_id, ob2_data_bundle_t *data_bundle) {
        ob2_status_t status;
        ob2_device_update_structured_data(m_device_handle, command_id, data_bundle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    static void release_data_bundle(ob2_data_bundle_t *data_bundle) {
        ob2_status_t status;
        ob2_data_bundle_release(data_bundle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
protected:
    static void firmware_update_state_callback(ob2_update_state_t state, const char *message, uint8_t percent, void *user_data) {
        auto dev = (device *)user_data;
        if(dev->m_firmware_update_state_cb != nullptr) {
            dev->m_firmware_update_state_cb(state, std::string(message), percent);
        }
    }
 
    static void capture_callback(ob2_capture_t capture_handle, void *user_data) {
        auto dev = (device *)user_data;
        if(dev->m_capture_cb != nullptr) {
            dev->m_capture_cb(std::make_shared<capture>(std::move(capture_handle)));
        }
    }
 
    static void imu_sample_callback(ob2_imu_sample_t imu_sample_handle, void *user_data) {
        auto dev = (device *)user_data;
        if(dev->m_imu_sample_cb != nullptr) {
            dev->m_imu_sample_cb(std::make_shared<imu_sample>(std::move(imu_sample_handle)));
        }
    }
 
protected:
    firmware_update_state_cb m_firmware_update_state_cb;
    capture_cb               m_capture_cb;
    imu_sample_cb            m_imu_sample_cb;
 
    ob2_device_t m_device_handle;
};
 
}  // namespace ob2