Context.hpp

Go to the documentation of this file.

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#pragma once
 
#include "libobsensor/h/Context.h"
#include "Types.hpp"
#include "Error.hpp"
 
#include <functional>
#include <memory>
 
namespace ob {
 
// forward declarations
class Device;
class DeviceInfo;
class DeviceList;
 
class Context {
public:
    typedef std::function<void(std::shared_ptr<DeviceList> removedList, std::shared_ptr<DeviceList> addedList)> DeviceChangedCallback;

    typedef std::function<void(OBLogSeverity severity, const char *logMsg)> LogCallback;
 
private:
    ob_context           *impl_ = nullptr;
    DeviceChangedCallback deviceChangedCallback_;
    // static LogCallback    logCallback_;
 
public:
    explicit Context(const char *configPath = "") {
        ob_error *error = nullptr;
        impl_           = ob_create_context_with_config(configPath, &error);
        Error::handle(&error);
    }

    ~Context() noexcept {
        ob_error *error = nullptr;
        ob_delete_context(impl_, &error);
        Error::handle(&error, false);
    }

    std::shared_ptr<DeviceList> queryDeviceList() const {
        ob_error *error = nullptr;
        auto      list  = ob_query_device_list(impl_, &error);
        Error::handle(&error);
        return std::make_shared<DeviceList>(list);
    }

    void enableNetDeviceEnumeration(bool enable) const {
        ob_error *error = nullptr;
        ob_enable_net_device_enumeration(impl_, enable, &error);
        Error::handle(&error);
    }

    bool forceIp(const char *macAddress, const OBNetIpConfig &config) {
        ob_error *error = nullptr;
        auto      res   = ob_force_ip_config(macAddress, config, &error);
        Error::handle(&error);
        return res;
    }

    std::shared_ptr<Device> createNetDevice(const char *address, uint16_t port) const {
        ob_error *error  = nullptr;
        auto      device = ob_create_net_device(impl_, address, port, &error);
        Error::handle(&error);
        return std::make_shared<Device>(device);
    }

    void setDeviceChangedCallback(DeviceChangedCallback callback) {
        deviceChangedCallback_ = callback;
        ob_error *error        = nullptr;
        ob_set_device_changed_callback(impl_, &Context::deviceChangedCallback, this, &error);
        Error::handle(&error);
    }

    void enableDeviceClockSync(uint64_t repeatIntervalMsec) const {
        ob_error *error = nullptr;
        ob_enable_device_clock_sync(impl_, repeatIntervalMsec, &error);
        Error::handle(&error);
    }

    void freeIdleMemory() const {
        ob_error *error = nullptr;
        ob_free_idle_memory(impl_, &error);
        Error::handle(&error);
    }

    void setUvcBackendType(OBUvcBackendType type) const {
        ob_error *error = nullptr;
        ob_set_uvc_backend_type(impl_, type, &error);
        Error::handle(&error);
    }

    static void setLoggerSeverity(OBLogSeverity severity) {
        ob_error *error = nullptr;
        ob_set_logger_severity(severity, &error);
        Error::handle(&error);
    }

    static void setLoggerToFile(OBLogSeverity severity, const char *directory) {
        ob_error *error = nullptr;
        ob_set_logger_to_file(severity, directory, &error);
        Error::handle(&error);
    }

    static void setLoggerToConsole(OBLogSeverity severity) {
        ob_error *error = nullptr;
        ob_set_logger_to_console(severity, &error);
        Error::handle(&error);
    }

    static void setLoggerToCallback(OBLogSeverity severity, LogCallback callback) {
        ob_error *error           = nullptr;
        Context::getLogCallback() = callback;
        ob_set_logger_to_callback(severity, &Context::logCallback, &Context::getLogCallback(), &error);
        Error::handle(&error);
    }

    static void setExtensionsDirectory(const char *directory) {
        ob_error *error = nullptr;
        ob_set_extensions_directory(directory, &error);
        Error::handle(&error);
    }
 
private:
    static void deviceChangedCallback(ob_device_list *removedList, ob_device_list *addedList, void *userData) {
        auto ctx = static_cast<Context *>(userData);
        if(ctx && ctx->deviceChangedCallback_) {
            auto removed = std::make_shared<DeviceList>(removedList);
            auto added   = std::make_shared<DeviceList>(addedList);
            ctx->deviceChangedCallback_(removed, added);
        }
    }
 
    static void logCallback(OBLogSeverity severity, const char *logMsg, void *userData) {
        auto cb = static_cast<LogCallback *>(userData);
        if(cb) {
            (*cb)(severity, logMsg);
        }
    }
 
    // Lazy initialization of the logcallback_. The purpose is to initialize logcallback_ in .hpp
    static LogCallback &getLogCallback() {
        static LogCallback logCallback_ = nullptr;
        return logCallback_;
    }
 
// for backward compatibility
#define enableMultiDeviceSync enableDeviceClockSync
};
}  // namespace ob