OB2Context.hpp

浏览该文件的文档.

#pragma once
 
#include "OB2Types.hpp"
#include "OB2Device.hpp"
 
extern "C" {
#include "h/ob2context.h"
}
 
#include <memory>
 
namespace ob2 {
 
class context {
public:
    context(std::string config_file_path = OB2_DEFAULT_SDK_CONFIG_FILE_PATH) : m_device_installed_callback(nullptr), m_device_removed_callback(nullptr) {
        ob2_status_t status;
        m_context_handle = ob2_create_context_with_config(config_file_path.c_str(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ~context() noexcept {
        ob2_status_t status;
        if(m_context_handle != nullptr) {
            ob2_release_context(m_context_handle, &status);
        }
    }
 
public:
    static ob2_version_t get_version() noexcept {
        return ob2_get_version();
    }
 
    static ob2_version_t get_core_version() noexcept {
        return ob2_get_core_version();
    }
 
    static void set_log_severity_threshold(ob2_logger_type_t logger_type, ob2_log_severity_t severity) {
        ob2_status_t status;
        ob2_set_log_severity_threshold(logger_type, severity, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    static void set_log_output_directory(const std::string &directory) {
        ob2_status_t status;
        ob2_set_log_output_directory(directory.c_str(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
public:
    virtual std::vector<ob2_device_installation_info_t> get_installed_device_info_list() {
        ob2_status_t status;
        auto         count = ob2_context_get_installed_device_count(m_context_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
 
        std::vector<ob2_device_installation_info_t> device_info_list;
        for(uint32_t index = 0; index < count; index++) {
            auto device_info = ob2_context_get_installed_device_info(m_context_handle, index, &status);
            CHECK_OB2_STATUS_ERROR_THROW(status);
            device_info_list.push_back(device_info);
        }
        return device_info_list;
    }
 
    virtual std::shared_ptr<device> open_device(uint32_t index) {
        ob2_status_t status;
        auto         device_handle = ob2_context_open_device(m_context_handle, index, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<device>(std::move(device_handle));
    }
 
    virtual std::shared_ptr<device> open_device_by_serial_number(const std::string &serial_number) {
        ob2_status_t status;
        auto         device_handle = ob2_context_open_device_by_serial_number(m_context_handle, serial_number.c_str(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<device>(std::move(device_handle));
    }
 
    virtual std::shared_ptr<device> open_device_by_url(const std::string &url) {
        ob2_status_t status;
        auto         device_handle = ob2_context_open_device_by_url(m_context_handle, url.c_str(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<device>(std::move(device_handle));
    }
 
    virtual std::shared_ptr<device> open_net_device(const std::string &address, uint16_t port = 8090) {
        ob2_status_t status;
        auto         device_handle = ob2_context_open_net_device(m_context_handle, address.c_str(), port, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<device>(std::move(device_handle));
    }
 
    virtual void set_device_installed_callback(device_info_cb cb) {
        m_device_installed_callback = cb;
 
        ob2_status_t status;
        ob2_context_set_device_installed_callback(m_context_handle, &context::device_installed_callback, this, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_device_removed_callback(device_info_cb cb) {
        m_device_removed_callback = cb;
 
        ob2_status_t status;
        ob2_context_set_device_removed_callback(m_context_handle, &context::device_removed_callback, this, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
protected:
    static void device_installed_callback(ob2_device_installation_info_t device_info, void *user_data) {
        auto ctx = (context *)user_data;
        if(ctx->m_device_installed_callback != nullptr) {
            ctx->m_device_installed_callback(device_info);
        }
    }
 
    static void device_removed_callback(ob2_device_installation_info_t device_info, void *user_data) {
        auto ctx = (context *)user_data;
        if(ctx->m_device_removed_callback != nullptr) {
            ctx->m_device_removed_callback(device_info);
        }
    }
 
protected:
    device_info_cb m_device_installed_callback;
    device_info_cb m_device_removed_callback;
    ob2_context_t  m_context_handle;
};
 
}  // namespace ob2