Device.hpp

Go to the documentation of this file.

 
#pragma once
#include "Types.hpp"
 
#include "libobsensor/h/Property.h"
#include "libobsensor/hpp/Filter.hpp"
#include <memory>
#include <string>
#include <vector>
 
struct DeviceImpl;
struct DeviceInfoImpl;
struct DeviceListImpl;
struct CameraParamListImpl;
 
namespace ob {
class SensorList;
class Context;
class DeviceInfo;
class Sensor;
class CameraParamList;
class OBDepthWorkModeList;
class DevicePresetList;
 
class OB_EXTENSION_API Device {
protected:
    std::unique_ptr<DeviceImpl> impl_;
 
    Device(Device &&device);
 
public:
    Device(std::unique_ptr<DeviceImpl> impl);
    virtual ~Device() noexcept;
 
    std::shared_ptr<DeviceInfo> getDeviceInfo();
 
    std::shared_ptr<SensorList> getSensorList();
 
    std::shared_ptr<Sensor> getSensor(OBSensorType type);
 
    void setIntProperty(OBPropertyID propertyId, int32_t property);
 
    void setFloatProperty(OBPropertyID propertyId, float property);
 
    void setBoolProperty(OBPropertyID propertyId, bool property);
 
    int32_t getIntProperty(OBPropertyID propertyId);
 
    float getFloatProperty(OBPropertyID propertyId);
 
    bool getBoolProperty(OBPropertyID propertyId);
 
    OBIntPropertyRange getIntPropertyRange(OBPropertyID propertyId);
 
    OBFloatPropertyRange getFloatPropertyRange(OBPropertyID propertyId);
 
    OBBoolPropertyRange getBoolPropertyRange(OBPropertyID propertyId);
 
    void writeAHB(uint32_t reg, uint32_t mask, uint32_t value);
 
    void readAHB(uint32_t reg, uint32_t mask, uint32_t *value);
 
    void writeI2C(uint32_t moduleId, uint32_t reg, uint32_t mask, uint32_t value);
 
    void readI2C(uint32_t moduleId, uint32_t reg, uint32_t mask, uint32_t *value);
 
    void writeFlash(uint32_t offset, const void *data, uint32_t dataSize, SetDataCallback callback, bool async = false);
 
    void readFlash(uint32_t offset, uint32_t dataSize, GetDataCallback callback, bool async = false);
 
    void writeCustomerData(const void *data, uint32_t dataSize);
 
    void readCustomerData(void *data, uint32_t *dataSize);
 
    void setRawData(OBPropertyID propertyId, const void *data, uint32_t dataSize, SetDataCallback callback, bool async = false);
 
    void getRawData(OBPropertyID propertyId, GetDataCallback callback, bool async = false);
 
    void setStructuredData(OBPropertyID propertyId, const void *data, uint32_t dataSize);
 
    void getStructuredData(OBPropertyID propertyId, void *data, uint32_t *dataSize);
 
    void setStructuredDataExt(OBPropertyID propertyId, std::shared_ptr<OBDataBundle> dataBundle, SetDataCallback callback);
 
    std::shared_ptr<OBDataBundle> getStructuredDataExt(OBPropertyID propertyId);
 
    OBProtocolVersion getProtocolVersion();
 
    OBCmdVersion getCmdVersion(OBPropertyID propertyId);
 
    uint32_t getSupportedPropertyCount();
 
    OBPropertyItem getSupportedProperty(uint32_t index);
 
    bool isPropertySupported(OBPropertyID propertyId, OBPermissionType permission);
 
    bool isGlobalTimestampSupported();
 
    void deviceUpgrade(const char *filePath, DeviceUpgradeCallback callback, bool async = true);
 
    void deviceUpgradeFromData(const char *fileData, uint32_t fileSize, DeviceUpgradeCallback callback, bool async = true);
 
    void sendFile(const char *filePath, const char *dstPath, SendFileCallback callback, bool async = true);
 
    OBDeviceState getDeviceState();
 
    void setDeviceStateChangedCallback(DeviceStateChangedCallback callback);
 
    bool activateAuthorization(const char *authCode);
 
    void writeAuthorizationCode(const char *authCodeStr);
 
    std::shared_ptr<CameraParamList> getCalibrationCameraParamList();
 
    OBDepthWorkMode getCurrentDepthWorkMode();
 
    OBStatus switchDepthWorkMode(const OBDepthWorkMode &workMode);
 
    OBStatus switchDepthWorkMode(const char *modeName);
 
    std::shared_ptr<OBDepthWorkModeList> getDepthWorkModeList();
 
    void reboot();
 
    void reboot(uint32_t delayMs);
 
    DEPRECATED uint64_t syncDeviceTime();
 
    DEPRECATED OBDeviceSyncConfig getSyncConfig();
 
    DEPRECATED void setSyncConfig(const OBDeviceSyncConfig &deviceSyncConfig);
 
    uint16_t getSupportedMultiDeviceSyncModeBitmap();
 
    void setMultiDeviceSyncConfig(const OBMultiDeviceSyncConfig &config);
 
    OBMultiDeviceSyncConfig getMultiDeviceSyncConfig();
 
    void triggerCapture();
 
    void setTimestampResetConfig(const OBDeviceTimestampResetConfig &config);
 
    OBDeviceTimestampResetConfig getTimestampResetConfig();
 
    void timestampReset();
 
#define timerReset timestampReset
 
    void timerSyncWithHost();
 
    void loadDepthFilterConfig(const char *filePath);
 
    void resetDefaultDepthFilterConfig();
 
    const char *getCurrentPresetName();
 
    const char *getCurrentDepthModeName();
 
    void loadPreset(const char *presetName);
 
    std::shared_ptr<DevicePresetList> getAvailablePresetList();
 
    void loadPresetFromJsonFile(const char *filePath);
 
    void loadPresetFromJsonData(const char *presetName, const uint8_t *data, uint32_t size);
 
    void exportSettingsAsPresetJsonFile(const char *filePath);
 
    void exportSettingsAsPresetJsonData(const char *presetName, const uint8_t **data, uint32_t *dataSize);
 
    friend class Pipeline;
    friend class Recorder;
    friend class CoordinateTransformHelper;
};
 
class OB_EXTENSION_API DeviceInfo {
private:
    std::unique_ptr<DeviceInfoImpl> impl_;
 
public:
    DeviceInfo(std::unique_ptr<DeviceInfoImpl> impl);
    virtual ~DeviceInfo() noexcept;
 
    const char *name();
 
    int pid();
 
    int vid();
 
    const char *uid();
 
    const char *serialNumber();
 
    const char *firmwareVersion();
 
    DEPRECATED const char *usbType();
 
    const char *connectionType();
 
    const char *ipAddress();
 
    const char *hardwareVersion();
 
    const char *supportedMinSdkVersion();
 
    const char *extensionInfo();
 
    const char *asicName();
 
    OBDeviceType deviceType();
 
    friend class Context;
    friend class DeviceList;
    friend class Pipeline;
};
 
class OB_EXTENSION_API DeviceList {
private:
    std::unique_ptr<DeviceListImpl> impl_;
 
public:
    DeviceList(std::unique_ptr<DeviceListImpl> impl);
    ~DeviceList() noexcept;
 
    uint32_t deviceCount();
 
    DEPRECATED const char *name(uint32_t index);
 
    int pid(uint32_t index);
 
    int vid(uint32_t index);
 
    const char *uid(uint32_t index);
 
    const char *serialNumber(uint32_t index);
 
    const char *connectionType(uint32_t index);
 
    const char *ipAddress(uint32_t index);
 
    std::shared_ptr<Device> getDevice(uint32_t index);
 
    std::shared_ptr<Device> getDeviceBySN(const char *serialNumber);
 
    std::shared_ptr<Device> getDeviceByUid(const char *uid);
};
 
class OB_EXTENSION_API CameraParamList {
private:
    std::unique_ptr<CameraParamListImpl> impl_;
 
public:
    CameraParamList(std::unique_ptr<CameraParamListImpl> impl);
    ~CameraParamList() noexcept;
 
    uint32_t count();
 
    OBCameraParam getCameraParam(uint32_t index);
};
 
class OB_EXTENSION_API OBDepthWorkModeList {
private:
    std::unique_ptr<OBDepthWorkModeListImpl> impl_;
 
public:
    OBDepthWorkModeList(std::unique_ptr<OBDepthWorkModeListImpl> impl_);
    ~OBDepthWorkModeList();
 
    uint32_t count();
 
    OBDepthWorkMode getOBDepthWorkMode(uint32_t index);
 
    const char *getName(uint32_t index);
 
    OBDepthWorkMode operator[](uint32_t index);
};
 
class OB_EXTENSION_API DevicePresetList {
private:
    std::unique_ptr<DevicePresetListImpl> impl_;
 
public:
    DevicePresetList(std::unique_ptr<DevicePresetListImpl> impl);
    ~DevicePresetList() noexcept;
 
    uint32_t count();
 
    const char *getName(uint32_t index);
 
    bool hasPreset(const char *name);
};
 
}  // namespace ob