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>
#include <string>
#include <unordered_map>
#include <mutex>
 
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;
 
    struct DeviceChangedCallbackContext {
        Context              *ctx;
        uint64_t              callbackId;
        DeviceChangedCallback callback;
    };
 
private:
    ob_context *impl_ = nullptr;
    std::mutex  callbackMtx_;
 
    std::mutex   legacyCallbackMtx_;
    OBCallbackId legacyCallbackId_ = INVALID_CALLBACK_ID;
 
    std::unordered_map<OBCallbackId, std::unique_ptr<DeviceChangedCallbackContext>> devChangedCallbacks_;
    // 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 {
        // delete contex of C API, which will auto unregister all callbacks
        ob_error *error = nullptr;
        ob_delete_context(impl_, &error);
        Error::handle(&error, false);
    }

    void setTimestampClockType(OBClockType type) const {
        ob_error *error = nullptr;
        ob_context_set_timestamp_clock_type(impl_, type, &error);
        Error::handle(&error);
    }

    OBClockType getTimestampClockType() const {
        ob_error *error = nullptr;
        auto      type  = ob_context_get_timestamp_clock_type(impl_, &error);
        Error::handle(&error);
        return type;
    }

    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;
    }

    bool sendActionCommand(uint32_t deviceKey, uint32_t groupKey, uint32_t groupMask, const char *destIp = "255.255.255.255", uint64_t scheduledTime = 0) {
        ob_error *error = nullptr;
        bool      ok    = ob_send_action_command(deviceKey, groupKey, groupMask, destIp, scheduledTime, &error);
        Error::handle(&error);
        return ok;
    }

    void setGvcpPortScheme(OBGvcpPortScheme scheme) {
        ob_error *error = nullptr;
        ob_set_gvcp_port_scheme(impl_, scheme, &error);
        Error::handle(&error);
    }

    OBGvcpPortScheme getGvcpPortScheme() const {
        ob_error *error  = nullptr;
        auto      scheme = ob_get_gvcp_port_scheme(impl_, &error);
        Error::handle(&error);
        return scheme;
    }

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

    void setDeviceChangedCallback(DeviceChangedCallback callback) {
        std::lock_guard<std::mutex> lock(legacyCallbackMtx_);
        // remove the last callback first
        if(legacyCallbackId_ != INVALID_CALLBACK_ID) {
            unregisterDeviceChangedCallback(legacyCallbackId_);
        }
        // register the new callback
        legacyCallbackId_ = registerDeviceChangedCallback(callback);
    }
 
    OBCallbackId registerDeviceChangedCallback(DeviceChangedCallback callback) {
        ob_error *error       = nullptr;
        auto      cbCtxHolder = std::unique_ptr<DeviceChangedCallbackContext>(new DeviceChangedCallbackContext({ this, 0, nullptr }));
        auto      id          = ob_register_device_changed_callback(impl_, &Context::deviceChangedCallback, (void *)cbCtxHolder.get(), &error);
        Error::handle(&error);
 
        cbCtxHolder->callbackId = id;
        cbCtxHolder->callback   = callback;
        {
            std::unique_lock<std::mutex> lock(callbackMtx_);
            devChangedCallbacks_[id] = std::move(cbCtxHolder);
        }
        return id;
    }
 
    void unregisterDeviceChangedCallback(OBCallbackId id) {
        ob_error *error = nullptr;
        ob_unregister_device_changed_callback(impl_, id, &error);
        {
            std::unique_lock<std::mutex> lock(callbackMtx_);
            if(devChangedCallbacks_.count(id)) {
                devChangedCallbacks_.erase(id);
            }
        }
        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 syncDeviceHardwarePPSTime(uint64_t hardwarePPSTime) const {
        ob_error *error = nullptr;
        ob_sync_device_hardware_pps_time(impl_, hardwarePPSTime, &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 setLoggerFileName(const std::string &fileName) {
        ob_error *error = nullptr;
        ob_set_logger_file_name(fileName.c_str(), &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 logExternalMessage(OBLogSeverity severity, const std::string &module, const std::string &message, const std::string &file,
                                   const std::string &func, int line) {
        ob_error *error = nullptr;
        ob_log_external_message(severity, module.c_str(), message.c_str(), file.c_str(), func.c_str(), line, &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 cbCtx = static_cast<DeviceChangedCallbackContext *>(userData);
        if(cbCtx && cbCtx->ctx && cbCtx->callbackId != INVALID_CALLBACK_ID) {
            DeviceChangedCallback callbackCopy;
            {
                // preventing the captured variables from being released.
                std::unique_lock<std::mutex> lock(cbCtx->ctx->callbackMtx_);
                if(cbCtx->ctx->devChangedCallbacks_.count(cbCtx->callbackId)) {
                    callbackCopy = cbCtx->callback;
                }
            }
            auto removed = std::make_shared<DeviceList>(removedList);
            auto added   = std::make_shared<DeviceList>(addedList);
            callbackCopy(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