Device.hpp

Go to the documentation of this file.

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

#pragma once
#include "Types.hpp"
 
#include "libobsensor/h/Property.h"
#include "libobsensor/h/Device.h"
#include "libobsensor/h/Advanced.h"
#include "libobsensor/hpp/Filter.hpp"
#include "libobsensor/hpp/Sensor.hpp"
 
#include "Error.hpp"
#include <memory>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
 
namespace ob {
 
class DeviceInfo;
class SensorList;
class DevicePresetList;
class ColorPresetList;
class OBDepthWorkModeList;
class CameraParamList;
class DeviceFrameInterleaveList;
class PresetResolutionConfigList;
 
class Device {
public:
    typedef std::function<void(OBFwUpdateState state, const char *message, uint8_t percent)> DeviceFwUpdateCallback;

    typedef std::function<void(OBDeviceState state, const char *message)> DeviceStateChangedCallback;
 
protected:
    ob_device                 *impl_ = nullptr;
    DeviceStateChangedCallback deviceStateChangeCallback_;
    DeviceFwUpdateCallback     fwUpdateCallback_;
 
public:
    explicit Device(ob_device_t *impl) : impl_(impl) {}
 
    Device(Device &&other) noexcept : impl_(other.impl_) {
        other.impl_ = nullptr;
    }
 
    Device &operator=(Device &&other) noexcept {
        if(this != &other) {
            ob_error *error = nullptr;
            ob_delete_device(impl_, &error);
            Error::handle(&error);
            impl_       = other.impl_;
            other.impl_ = nullptr;
        }
        return *this;
    }
 
    Device(const Device &)            = delete;
    Device &operator=(const Device &) = delete;
 
    virtual ~Device() noexcept {
        ob_error *error = nullptr;
        ob_delete_device(impl_, &error);
        Error::handle(&error, false);
    }
 
    ob_device_t *getImpl() const {
        return impl_;
    }

    std::shared_ptr<DeviceInfo> getDeviceInfo() const {
        ob_error *error = nullptr;
        auto      info  = ob_device_get_device_info(impl_, &error);
        Error::handle(&error);
        return std::make_shared<DeviceInfo>(info);
    }

    bool isExtensionInfoExist(const std::string &infoKey) const {
        ob_error *error = nullptr;
        auto      exist = ob_device_is_extension_info_exist(impl_, infoKey.c_str(), &error);
        Error::handle(&error);
        return exist;
    }

    const char *getExtensionInfo(const std::string &infoKey) const {
        ob_error   *error = nullptr;
        const char *info  = ob_device_get_extension_info(impl_, infoKey.c_str(), &error);
        Error::handle(&error);
        return info;
    }

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

    std::shared_ptr<Sensor> getSensor(OBSensorType type) const {
        ob_error *error  = nullptr;
        auto      sensor = ob_device_get_sensor(impl_, type, &error);
        Error::handle(&error);
        return std::make_shared<Sensor>(sensor);
    }

    void setIntProperty(OBPropertyID propertyId, int32_t value) const {
        ob_error *error = nullptr;
        ob_device_set_int_property(impl_, propertyId, value, &error);
        Error::handle(&error);
    }

    void setFloatProperty(OBPropertyID propertyId, float value) const {
        ob_error *error = nullptr;
        ob_device_set_float_property(impl_, propertyId, value, &error);
        Error::handle(&error);
    }

    void setBoolProperty(OBPropertyID propertyId, bool value) const {
        ob_error *error = nullptr;
        ob_device_set_bool_property(impl_, propertyId, value, &error);
        Error::handle(&error);
    }

    int32_t getIntProperty(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      value = ob_device_get_int_property(impl_, propertyId, &error);
        Error::handle(&error);
        return value;
    }

    float getFloatProperty(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      value = ob_device_get_float_property(impl_, propertyId, &error);
        Error::handle(&error);
        return value;
    }

    bool getBoolProperty(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      value = ob_device_get_bool_property(impl_, propertyId, &error);
        Error::handle(&error);
        return value;
    }

    OBIntPropertyRange getIntPropertyRange(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      range = ob_device_get_int_property_range(impl_, propertyId, &error);
        Error::handle(&error);
        return range;
    }

    OBFloatPropertyRange getFloatPropertyRange(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      range = ob_device_get_float_property_range(impl_, propertyId, &error);
        Error::handle(&error);
        return range;
    }

    OBBoolPropertyRange getBoolPropertyRange(OBPropertyID propertyId) const {
        ob_error *error = nullptr;
        auto      range = ob_device_get_bool_property_range(impl_, propertyId, &error);
        Error::handle(&error);
        return range;
    }

    void setStructuredData(OBPropertyID propertyId, const uint8_t *data, uint32_t dataSize) const {
        ob_error *error = nullptr;
        ob_device_set_structured_data(impl_, propertyId, data, dataSize, &error);
        Error::handle(&error);
    }

    void getStructuredData(OBPropertyID propertyId, uint8_t *data, uint32_t *dataSize) const {
        ob_error *error = nullptr;
        ob_device_get_structured_data(impl_, propertyId, data, dataSize, &error);
        Error::handle(&error);
    }

    bool isLicenseAuthorizationSupported() const {
        ob_error *error = nullptr;
        auto      res   = ob_device_is_license_authorization_supported(impl_, &error);
        Error::handle(&error);
        return res;
    }

    void writeLicenseInfo(const std::string &licenseInfo) const {
        ob_error *error = nullptr;
        ob_device_write_license_info(impl_, licenseInfo.c_str(), static_cast<uint32_t>(licenseInfo.size()), &error);
        Error::handle(&error);
    }

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

    std::string readLicenseInfo() const {
        ob_error *error     = nullptr;
        char      buf[4096] = {};
        ob_device_read_license_info(impl_, buf, sizeof(buf), &error);
        Error::handle(&error);
        return std::string(buf);
    }

    void writeCustomerData(const void *data, uint32_t dataSize) {
        ob_error *error = nullptr;
        ob_device_write_customer_data(impl_, data, dataSize, &error);
        Error::handle(&error);
    }

    void readCustomerData(void *data, uint32_t *dataSize) {
        ob_error *error = nullptr;
        ob_device_read_customer_data(impl_, data, dataSize, &error);
        Error::handle(&error);
    }

    int getSupportedPropertyCount() const {
        ob_error *error = nullptr;
        auto      count = ob_device_get_supported_property_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    OBPropertyItem getSupportedProperty(uint32_t index) const {
        ob_error *error = nullptr;
        auto      item  = ob_device_get_supported_property_item(impl_, index, &error);
        Error::handle(&error);
        return item;
    }

    bool isPropertySupported(OBPropertyID propertyId, OBPermissionType permission) const {
        ob_error *error  = nullptr;
        auto      result = ob_device_is_property_supported(impl_, propertyId, permission, &error);
        Error::handle(&error);
        return result;
    }

    bool isGlobalTimestampSupported() const {
        ob_error *error  = nullptr;
        auto      result = ob_device_is_global_timestamp_supported(impl_, &error);
        Error::handle(&error);
        return result;
    }

    void enableGlobalTimestamp(bool enable) {
        ob_error *error = nullptr;
        ob_device_enable_global_timestamp(impl_, enable, &error);
        Error::handle(&error);
    }

    void updateFirmware(const char *filePath, DeviceFwUpdateCallback callback, bool async = true) {
        ob_error *error   = nullptr;
        fwUpdateCallback_ = callback;
        ob_device_update_firmware(impl_, filePath, &Device::firmwareUpdateCallback, async, this, &error);
        Error::handle(&error);
    }

    void updateFirmwareFromData(const uint8_t *firmwareData, uint32_t firmwareDataSize, DeviceFwUpdateCallback callback, bool async = true) {
        ob_error *error   = nullptr;
        fwUpdateCallback_ = callback;
        ob_device_update_firmware_from_data(impl_, firmwareData, firmwareDataSize, &Device::firmwareUpdateCallback, async, this, &error);
        Error::handle(&error);
    }

    void updateOptionalDepthPresets(const char filePathList[][OB_PATH_MAX], uint8_t pathCount, DeviceFwUpdateCallback callback) {
        ob_error *error   = nullptr;
        fwUpdateCallback_ = callback;
        ob_device_update_optional_depth_presets(impl_, filePathList, pathCount, &Device::firmwareUpdateCallback, this, &error);
        Error::handle(&error);
    }

    void updateOptionalDepthPresets(const std::vector<std::vector<uint8_t>> &dataList, DeviceFwUpdateCallback callback) {
        ob_error                      *error = nullptr;
        std::vector<OBDataView> presets;
        presets.reserve(dataList.size());
        for(const auto &data: dataList) {
            presets.push_back({data.data(), static_cast<uint32_t>(data.size())});
        }
        fwUpdateCallback_ = callback;
        auto count        = static_cast<uint8_t>(presets.size());
        ob_device_update_optional_depth_presets_from_data(impl_, presets.data(), count, &Device::firmwareUpdateCallback, this, &error);
        Error::handle(&error);
    }

    void setDeviceStateChangedCallback(DeviceStateChangedCallback callback) {
        ob_error *error            = nullptr;
        deviceStateChangeCallback_ = callback;
        ob_device_set_state_changed_callback(impl_, &Device::deviceStateChangedCallback, this, &error);
        Error::handle(&error);
    }
 
    static void deviceStateChangedCallback(OBDeviceState state, const char *message, void *userData) {
        auto device = static_cast<Device *>(userData);
        device->deviceStateChangeCallback_(state, message);
    }

    OBDepthWorkMode getCurrentDepthWorkMode() const {
        ob_error *error = nullptr;
        auto      mode  = ob_device_get_current_depth_work_mode(impl_, &error);
        Error::handle(&error);
        return mode;
    }

    const char *getCurrentDepthModeName() {
        ob_error *error = nullptr;
        auto      name  = ob_device_get_current_depth_work_mode_name(impl_, &error);
        Error::handle(&error);
        return name;
    }

    OBStatus switchDepthWorkMode(const OBDepthWorkMode &workMode) const {
        ob_error *error  = nullptr;
        auto      status = ob_device_switch_depth_work_mode(impl_, &workMode, &error);
        Error::handle(&error);
        return status;
    }

    OBStatus switchDepthWorkMode(const char *modeName) const {
        ob_error *error  = nullptr;
        auto      status = ob_device_switch_depth_work_mode_by_name(impl_, modeName, &error);
        Error::handle(&error);
        return status;
    }

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

    bool isColorPresetSupported() const {
        ob_error *error  = nullptr;
        auto      result = ob_device_is_color_preset_supported(impl_, &error);
        Error::handle(&error);
        return result;
    }

    const char *getCurrentColorPresetName() const {
        ob_error   *error = nullptr;
        const char *name  = ob_device_get_current_color_preset_name(impl_, &error);
        Error::handle(&error);
        return name;
    }

    void switchColorPreset(const char *presetName) const {
        ob_error *error = nullptr;
        ob_device_switch_color_preset(impl_, presetName, &error);
        Error::handle(&error);
    }

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

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

    void reboot(uint32_t delayMs) const {
        setIntProperty(OB_PROP_DEVICE_REBOOT_DELAY_INT, delayMs);
        reboot();
    }

    bool syncDeviceHardwarePPSTime(uint64_t hardwarePPSTime) const {
        ob_error *error   = nullptr;
        bool      success = ob_device_sync_hardware_pps_time(impl_, hardwarePPSTime, &error);
        Error::handle(&error);
        return success;
    }

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

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

    bool isFirmwareLogEnabled() const {
        ob_error *error  = nullptr;
        bool      enable = ob_device_is_firmware_log_enabled(impl_, &error);
        Error::handle(&error);
        return enable;
    }

    void setMonitorPollInterval(uint32_t intervalMs) const {
        ob_error *error = nullptr;
        ob_device_set_monitor_poll_interval(impl_, intervalMs, &error);
        Error::handle(&error);
    }

    uint32_t getMonitorPollInterval() const {
        ob_error *error      = nullptr;
        auto      intervalMs = ob_device_get_monitor_poll_interval(impl_, &error);
        Error::handle(&error);
        return intervalMs;
    }

    uint16_t getSupportedMultiDeviceSyncModeBitmap() const {
        ob_error *error = nullptr;
        auto      mode  = ob_device_get_supported_multi_device_sync_mode_bitmap(impl_, &error);
        Error::handle(&error);
        return mode;
    }

    void setMultiDeviceSyncConfig(const OBMultiDeviceSyncConfig &config) const {
        ob_error *error = nullptr;
        ob_device_set_multi_device_sync_config(impl_, &config, &error);
        Error::handle(&error);
    }

    OBMultiDeviceSyncConfig getMultiDeviceSyncConfig() const {
        ob_error *error  = nullptr;
        auto      config = ob_device_get_multi_device_sync_config(impl_, &error);
        Error::handle(&error);
        return config;
    }

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

    void setTimestampResetConfig(const OBDeviceTimestampResetConfig &config) const {
        ob_error *error = nullptr;
        ob_device_set_timestamp_reset_config(impl_, &config, &error);
        Error::handle(&error);
    }

    OBDeviceTimestampResetConfig getTimestampResetConfig() const {
        ob_error *error  = nullptr;
        auto      config = ob_device_get_timestamp_reset_config(impl_, &error);
        Error::handle(&error);
        return config;
    }

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

    inline void timerReset() const {
        timestampReset();
    }

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

    const char *getCurrentPresetName() const {
        ob_error   *error = nullptr;
        const char *name  = ob_device_get_current_preset_name(impl_, &error);
        Error::handle(&error);
        return name;
    }

    void loadPreset(const char *presetName) const {
        ob_error *error = nullptr;
        ob_device_load_preset(impl_, presetName, &error);
        Error::handle(&error);
    }

    void loadPreset(const char *presetName, const char *version) const {
        ob_error *error = nullptr;
        ob_device_load_preset_by_depth_work_mode_version(impl_, presetName, version, &error);
        Error::handle(&error);
    }

    const char *getCurrentPresetDepthWorkModeVersion() const {
        ob_error   *error   = nullptr;
        const char *version = ob_device_get_current_preset_depth_work_mode_version(impl_, &error);
        Error::handle(&error);
        return version;
    }

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

    void loadPresetFromJsonFile(const char *filePath) const {
        ob_error *error = nullptr;
        ob_device_load_preset_from_json_file(impl_, filePath, &error);
        Error::handle(&error);
    }

    void loadPresetFromJsonData(const char *presetName, const uint8_t *data, uint32_t size) {
        ob_error *error = nullptr;
        ob_device_load_preset_from_json_data(impl_, presetName, data, size, &error);
    }

    void exportSettingsAsPresetJsonData(const char *presetName, const uint8_t **data, uint32_t *dataSize) {
        ob_error *error = nullptr;
        ob_device_export_current_settings_as_preset_json_data(impl_, presetName, data, dataSize, &error);
    }

    void exportSettingsAsPresetJsonFile(const char *filePath) const {
        ob_error *error = nullptr;
        ob_device_export_current_settings_as_preset_json_file(impl_, filePath, &error);
        Error::handle(&error);
    }

    OBDeviceState getDeviceState() {
        OBDeviceState state = {};
        ob_error     *error = nullptr;
        state               = ob_device_get_device_state(impl_, &error);
        return state;
    }

    void sendAndReceiveData(const uint8_t *sendData, uint32_t sendDataSize, uint8_t *receiveData, uint32_t *receiveDataSize) const {
        ob_error *error = nullptr;
        ob_device_send_and_receive_data(impl_, sendData, sendDataSize, receiveData, receiveDataSize, &error);
        Error::handle(&error);
    }

    bool isFrameInterleaveSupported() const {
        ob_error *error = nullptr;
        bool      ret   = ob_device_is_frame_interleave_supported(impl_, &error);
        Error::handle(&error);
        return ret;
    }

    void loadFrameInterleave(const char *frameInterleaveName) const {
        ob_error *error = nullptr;
        ob_device_load_frame_interleave(impl_, frameInterleaveName, &error);
        Error::handle(&error);
    }

    OB_EXPORT const char *getCurrentFrameInterleaveName() const {
        ob_error *error = nullptr;
        auto      name  = ob_device_get_current_frame_interleave_name(impl_, &error);
        Error::handle(&error);
        return name;
    }

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

    std::shared_ptr<PresetResolutionConfigList> getAvailablePresetResolutionConfigList() const {
        ob_error *error = nullptr;
        auto      list  = ob_device_get_available_preset_resolution_config_list(impl_, &error);
        Error::handle(&error);
        return std::make_shared<PresetResolutionConfigList>(list);
    }
 
private:
    static void firmwareUpdateCallback(ob_fw_update_state state, const char *message, uint8_t percent, void *userData) {
        auto device = static_cast<Device *>(userData);
        if(device && device->fwUpdateCallback_) {
            device->fwUpdateCallback_(state, message, percent);
        }
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    void deviceUpgrade(const char *filePath, DeviceFwUpdateCallback callback, bool async = true) {
        updateFirmware(filePath, callback, async);
    }
 
    void deviceUpgradeFromData(const uint8_t *firmwareData, uint32_t firmwareDataSize, DeviceFwUpdateCallback callback, bool async = true) {
        updateFirmwareFromData(firmwareData, firmwareDataSize, callback, async);
    }
 
    std::shared_ptr<CameraParamList> getCalibrationCameraParamList() {
        ob_error *error = nullptr;
        auto      impl  = ob_device_get_calibration_camera_param_list(impl_, &error);
        Error::handle(&error);
        return std::make_shared<CameraParamList>(impl);
    }
 
    void loadDepthFilterConfig(const char *filePath) {
        // In order to compile, some high-version compilers will warn that the function parameters are not used.
        (void)filePath;
    }
};

class DeviceInfo {
private:
    ob_device_info_t *impl_ = nullptr;
 
public:
    explicit DeviceInfo(ob_device_info_t *impl) : impl_(impl) {}
    ~DeviceInfo() noexcept {
        ob_error *error = nullptr;
        ob_delete_device_info(impl_, &error);
        Error::handle(&error, false);
    }

    const char *getName() const {
        ob_error   *error = nullptr;
        const char *name  = ob_device_info_get_name(impl_, &error);
        Error::handle(&error);
        return name;
    }

    int getPid() const {
        ob_error *error = nullptr;
        int       pid   = ob_device_info_get_pid(impl_, &error);
        Error::handle(&error);
        return pid;
    }

    int getVid() const {
        ob_error *error = nullptr;
        int       vid   = ob_device_info_get_vid(impl_, &error);
        Error::handle(&error);
        return vid;
    }

    const char *getUid() const {
        ob_error   *error = nullptr;
        const char *uid   = ob_device_info_get_uid(impl_, &error);
        Error::handle(&error);
        return uid;
    }

    const char *getSerialNumber() const {
        ob_error   *error = nullptr;
        const char *sn    = ob_device_info_get_serial_number(impl_, &error);
        Error::handle(&error);
        return sn;
    }

    const char *getFirmwareVersion() const {
        ob_error   *error   = nullptr;
        const char *version = ob_device_info_get_firmware_version(impl_, &error);
        Error::handle(&error);
        return version;
    }

    const char *getConnectionType() const {
        ob_error   *error = nullptr;
        const char *type  = ob_device_info_get_connection_type(impl_, &error);
        Error::handle(&error);
        return type;
    }

    const char *getIpAddress() const {
        ob_error   *error = nullptr;
        const char *ip    = ob_device_info_get_ip_address(impl_, &error);
        Error::handle(&error);
        return ip;
    }

    const char *getHardwareVersion() const {
        ob_error   *error   = nullptr;
        const char *version = ob_device_info_get_hardware_version(impl_, &error);
        Error::handle(&error);
        return version;
    }

    const char *getSupportedMinSdkVersion() const {
        ob_error   *error   = nullptr;
        const char *version = ob_device_info_get_supported_min_sdk_version(impl_, &error);
        Error::handle(&error);
        return version;
    }

    const char *getAsicName() const {
        ob_error   *error = nullptr;
        const char *name  = ob_device_info_get_asicName(impl_, &error);
        Error::handle(&error);
        return name;
    }

    OBDeviceType getDeviceType() const {
        ob_error    *error = nullptr;
        OBDeviceType type  = ob_device_info_get_device_type(impl_, &error);
        Error::handle(&error);
        return type;
    }

    const char *getDeviceSubnetMask() const {
        ob_error   *error      = nullptr;
        const char *subnetMask = ob_device_info_get_subnet_mask(impl_, &error);
        Error::handle(&error);
        return subnetMask;
    }

    const char *getDeviceGateway() const {
        ob_error   *error      = nullptr;
        const char *subnetMask = ob_device_info_get_gateway(impl_, &error);
        Error::handle(&error);
        return subnetMask;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    const char *getDevicegateway() {
        return getDeviceGateway();
    }
 
    const char *name() const {
        return getName();
    }
 
    int pid() const {
        return getPid();
    }
 
    int vid() const {
        return getVid();
    }
 
    const char *uid() const {
        return getUid();
    }
 
    const char *serialNumber() const {
        return getSerialNumber();
    }
 
    const char *firmwareVersion() const {
        return getFirmwareVersion();
    }
 
    const char *connectionType() const {
        return getConnectionType();
    }
 
    const char *ipAddress() const {
        return getIpAddress();
    }
 
    const char *hardwareVersion() const {
        return getHardwareVersion();
    }
 
    const char *supportedMinSdkVersion() const {
        return getSupportedMinSdkVersion();
    }
 
    const char *asicName() const {
        return getAsicName();
    }
 
    OBDeviceType deviceType() const {
        return getDeviceType();
    }
};

class DeviceList {
private:
    ob_device_list_t *impl_ = nullptr;
 
public:
    explicit DeviceList(ob_device_list_t *impl) : impl_(impl) {}
    ~DeviceList() noexcept {
        ob_error *error = nullptr;
        ob_delete_device_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() const {
        ob_error *error = nullptr;
        auto      count = ob_device_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    int getPid(uint32_t index) const {
        ob_error *error = nullptr;
        auto      pid   = ob_device_list_get_device_pid(impl_, index, &error);
        Error::handle(&error);
        return pid;
    }

    int getVid(uint32_t index) const {
        ob_error *error = nullptr;
        auto      vid   = ob_device_list_get_device_vid(impl_, index, &error);
        Error::handle(&error);
        return vid;
    }

    const char *getUid(uint32_t index) const {
        ob_error *error = nullptr;
        auto      uid   = ob_device_list_get_device_uid(impl_, index, &error);
        Error::handle(&error);
        return uid;
    }

    const char *getSerialNumber(uint32_t index) const {
        ob_error *error = nullptr;
        auto      sn    = ob_device_list_get_device_serial_number(impl_, index, &error);
        Error::handle(&error);
        return sn;
    }

    const char *getName(uint32_t index) const {
        ob_error *error = nullptr;
        auto      name  = ob_device_list_get_device_name(impl_, index, &error);
        Error::handle(&error);
        return name;
    }

    const char *getConnectionType(uint32_t index) const {
        ob_error *error = nullptr;
        auto      type  = ob_device_list_get_device_connection_type(impl_, index, &error);
        Error::handle(&error);
        return type;
    }

    const char *getIpAddress(uint32_t index) const {
        ob_error *error = nullptr;
        auto      ip    = ob_device_list_get_device_ip_address(impl_, index, &error);
        Error::handle(&error);
        return ip;
    }

    const char *getSubnetMask(uint32_t index) const {
        ob_error *error      = nullptr;
        auto      subnetMask = ob_device_list_get_device_subnet_mask(impl_, index, &error);
        Error::handle(&error);
        return subnetMask;
    }

    const char *getGateway(uint32_t index) const {
        ob_error *error   = nullptr;
        auto      gateway = ob_device_list_get_device_gateway(impl_, index, &error);
        Error::handle(&error);
        return gateway;
    }

    const char *getLocalMacAddress(uint32_t index) const {
        ob_error *error = nullptr;
        auto      mac   = ob_device_list_get_device_local_mac(impl_, index, &error);
        Error::handle(&error);
        return mac;
    }

    const char *getLocalIP(uint32_t index) const {
        ob_error *error = nullptr;
        auto      ip    = ob_device_list_get_device_local_ip(impl_, index, &error);
        Error::handle(&error);
        return ip;
    }

    uint8_t getLocalSubnetLength(uint32_t index) const {
        ob_error *error      = nullptr;
        auto      subnetMask = ob_device_list_get_device_local_subnet_length(impl_, index, &error);
        Error::handle(&error);
        return subnetMask;
    }

    const char *getLocalGateway(uint32_t index) const {
        ob_error *error   = nullptr;
        auto      gateway = ob_device_list_get_device_local_gateway(impl_, index, &error);
        Error::handle(&error);
        return gateway;
    }

    const char *getLocalNetInterfaceName(uint32_t index) const {
        ob_error *error      = nullptr;
        auto      netItfName = ob_device_list_get_device_local_net_if_name(impl_, index, &error);
        Error::handle(&error);
        return netItfName;
    }

    OBIpSourceType getIpSourceType(uint32_t index) const {
        ob_error *error     = nullptr;
        auto      ipSrcType = ob_device_list_get_device_ip_source_type(impl_, index, &error);
        Error::handle(&error);
        return ipSrcType;
    }

    const char *getUserName(uint32_t index) const {
        ob_error *error    = nullptr;
        auto      userName = ob_device_list_get_device_user_name(impl_, index, &error);
        Error::handle(&error);
        return userName;
    }

    OBDeviceAccessState queryDeviceAccessState(uint32_t index) const {
        ob_error *error = nullptr;
        auto      state = ob_device_list_query_device_access_state(impl_, index, &error);
        Error::handle(&error);
        return state;
    }

    OBDeviceAccessState queryDeviceAccessStateBySN(const char *serialNumber) const {
        ob_error *error = nullptr;
        auto      state = ob_device_list_query_device_access_state_by_serial_number(impl_, serialNumber, &error);
        Error::handle(&error);
        return state;
    }

    std::shared_ptr<Device> getDevice(uint32_t index, OBDeviceAccessMode accessMode = OB_DEVICE_DEFAULT_ACCESS) const {
        ob_error *error  = nullptr;
        auto      device = ob_device_list_get_device_ex(impl_, index, accessMode, &error);
        Error::handle(&error);
        return std::make_shared<Device>(device);
    }

    std::shared_ptr<Device> getDeviceBySN(const char *serialNumber, OBDeviceAccessMode accessMode = OB_DEVICE_DEFAULT_ACCESS) const {
        ob_error *error  = nullptr;
        auto      device = ob_device_list_get_device_by_serial_number_ex(impl_, serialNumber, accessMode, &error);
        Error::handle(&error);
        return std::make_shared<Device>(device);
    }

    std::shared_ptr<Device> getDeviceByUid(const char *uid, OBDeviceAccessMode accessMode = OB_DEVICE_DEFAULT_ACCESS) const {
        ob_error *error  = nullptr;
        auto      device = ob_device_list_get_device_by_uid_ex(impl_, uid, accessMode, &error);
        Error::handle(&error);
        return std::make_shared<Device>(device);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t deviceCount() const {
        return getCount();
    }
 
    int pid(uint32_t index) const {
        return getPid(index);
    }
 
    int vid(uint32_t index) const {
        return getVid(index);
    }
 
    const char *uid(uint32_t index) const {
        return getUid(index);
    }
 
    const char *serialNumber(uint32_t index) const {
        return getSerialNumber(index);
    }
 
    const char *name(uint32_t index) const {
        return getName(index);
    }
 
    const char *connectionType(uint32_t index) const {
        return getConnectionType(index);
    }
 
    const char *ipAddress(uint32_t index) const {
        return getIpAddress(index);
    }
};
 
class OBDepthWorkModeList {
private:
    ob_depth_work_mode_list_t *impl_ = nullptr;
 
public:
    explicit OBDepthWorkModeList(ob_depth_work_mode_list_t *impl) : impl_(impl) {}
    ~OBDepthWorkModeList() {
        ob_error *error = nullptr;
        ob_delete_depth_work_mode_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() {
        ob_error *error = nullptr;
        auto      count = ob_depth_work_mode_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    OBDepthWorkMode getOBDepthWorkMode(uint32_t index) {
        ob_error *error = nullptr;
        auto      mode  = ob_depth_work_mode_list_get_item(impl_, index, &error);
        Error::handle(&error);
        return mode;
    }

    OBDepthWorkMode operator[](uint32_t index) {
        return getOBDepthWorkMode(index);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t count() {
        return getCount();
    }
};

class DevicePresetList {
private:
    ob_device_preset_list_t *impl_ = nullptr;
 
public:
    explicit DevicePresetList(ob_device_preset_list_t *impl) : impl_(impl) {}
    ~DevicePresetList() noexcept {
        ob_error *error = nullptr;
        ob_delete_preset_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() {
        ob_error *error = nullptr;
        auto      count = ob_device_preset_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    const char *getName(uint32_t index) {
        ob_error   *error = nullptr;
        const char *name  = ob_device_preset_list_get_name(impl_, index, &error);
        Error::handle(&error);
        return name;
    }

    const char *getDepthWorkModeVersion(uint32_t index) {
        ob_error   *error   = nullptr;
        const char *version = ob_device_preset_list_get_depth_work_mode_version(impl_, index, &error);
        Error::handle(&error);
        return version;
    }

    bool hasPreset(const char *name) {
        ob_error *error  = nullptr;
        auto      result = ob_device_preset_list_has_preset(impl_, name, &error);
        Error::handle(&error);
        return result;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t count() {
        return getCount();
    }
};

class ColorPresetList {
private:
    ob_color_preset_list *impl_ = nullptr;
 
public:
    explicit ColorPresetList(ob_color_preset_list *impl) : impl_(impl) {}
    ~ColorPresetList() noexcept {
        ob_error *error = nullptr;
        ob_delete_color_preset_list(impl_, &error);
        Error::handle(&error, false);
    }
 
    uint32_t getCount() const {
        ob_error *error = nullptr;
        auto      count = ob_color_preset_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }
 
    const char *getName(uint32_t index) const {
        ob_error   *error = nullptr;
        const char *name  = ob_color_preset_list_get_name(impl_, index, &error);
        Error::handle(&error);
        return name;
    }
};

class CameraParamList {
private:
    ob_camera_param_list_t *impl_ = nullptr;
 
public:
    explicit CameraParamList(ob_camera_param_list_t *impl) : impl_(impl) {}
    ~CameraParamList() noexcept {
        ob_error *error = nullptr;
        ob_delete_camera_param_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() {
        ob_error *error = nullptr;
        auto      count = ob_camera_param_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    OBCameraParam getCameraParam(uint32_t index) {
        ob_error *error = nullptr;
        auto      param = ob_camera_param_list_get_param(impl_, index, &error);
        Error::handle(&error);
        return param;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t count() {
        return getCount();
    }
};

class DeviceFrameInterleaveList {
private:
    ob_device_frame_interleave_list_t *impl_ = nullptr;
 
public:
    explicit DeviceFrameInterleaveList(ob_device_frame_interleave_list_t *impl) : impl_(impl) {}
    ~DeviceFrameInterleaveList() noexcept {
        ob_error *error = nullptr;
        ob_delete_frame_interleave_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() {
        ob_error *error = nullptr;
        auto      count = ob_device_frame_interleave_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    const char *getName(uint32_t index) {
        ob_error   *error = nullptr;
        const char *name  = ob_device_frame_interleave_list_get_name(impl_, index, &error);
        Error::handle(&error);
        return name;
    }

    bool hasFrameInterleave(const char *name) {
        ob_error *error  = nullptr;
        auto      result = ob_device_frame_interleave_list_has_frame_interleave(impl_, name, &error);
        Error::handle(&error);
        return result;
    }
};

class PresetResolutionConfigList {
private:
    ob_preset_resolution_config_list_t *impl_ = nullptr;
 
public:
    explicit PresetResolutionConfigList(ob_preset_resolution_config_list_t *impl) : impl_(impl) {}
    ~PresetResolutionConfigList() noexcept {
        ob_error *error = nullptr;
        ob_delete_preset_resolution_config_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() {
        ob_error *error = nullptr;
        auto      count = ob_device_preset_resolution_config_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }
 
    /*
     *  @brief Get the device preset resolution ratio at the specified index
 
     *  @param[in] index the index of the device preset resolution ratio
     *
     *  @return OBPresetResolutionConfig the corresponding device preset resolution ratio
     */
    OBPresetResolutionConfig getPresetResolutionRatioConfig(uint32_t index) {
        ob_error *error  = nullptr;
        auto      config = ob_device_preset_resolution_config_list_get_item(impl_, index, &error);
        Error::handle(&error);
        return config;
    }
};
 
}  // namespace ob