orbbec-sdk-sys 0.1.2+2.5.5

Low-level Rust bindings for https://github.com/orbbec/OrbbecSDK_v2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

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

#pragma once

#include "IDevice.hpp"
#include "component/DeviceComponentBase.hpp"
#include "component/timestamp/GlobalTimestampFitter.hpp"
#include "component/monitor/DeviceMonitor.hpp"

#include <memory>

namespace libobsensor {
class IFirmwareUpdateGuard;

// FirmwareUpdateGuardFactory
class FirmwareUpdateGuardFactory : public DeviceComponentBase {
public:
    FirmwareUpdateGuardFactory(IDevice *owner);

    std::shared_ptr<IFirmwareUpdateGuard> create();
};

// IFirmwareUpdateGuard
class IFirmwareUpdateGuard {
public:
    virtual ~IFirmwareUpdateGuard() = default;

    virtual void preUpdate()  = 0;
    virtual void postUpdate() = 0;
};

// CompositeGuard
class CompositeGuard : public IFirmwareUpdateGuard {
public:
    explicit CompositeGuard() = default;
    explicit CompositeGuard(const std::vector<std::shared_ptr<IFirmwareUpdateGuard>> &guards);
    virtual ~CompositeGuard() noexcept override;

    CompositeGuard(CompositeGuard &&other) noexcept;
    CompositeGuard &operator=(CompositeGuard &&other) noexcept;

    CompositeGuard(const CompositeGuard &other)            = delete;
    CompositeGuard &operator=(const CompositeGuard &other) = delete;

    virtual void addGuard(std::shared_ptr<IFirmwareUpdateGuard> guard);
    virtual void preUpdate() override;
    virtual void postUpdate() override;

protected:
    std::vector<std::shared_ptr<IFirmwareUpdateGuard>> guards_;
};

// SeparateGuard
class NullGuard : public IFirmwareUpdateGuard {
public:
    explicit NullGuard(IDevice *owner);
    virtual ~NullGuard() noexcept override = default;

    virtual void preUpdate() override;
    virtual void postUpdate() override;
};

class FirmwareUpgradeStateGuard : public IFirmwareUpdateGuard {
public:
    explicit FirmwareUpgradeStateGuard(IDevice *owner);
    virtual ~FirmwareUpgradeStateGuard() noexcept override = default;

    FirmwareUpgradeStateGuard(FirmwareUpgradeStateGuard &&other) noexcept;
    FirmwareUpgradeStateGuard &operator=(FirmwareUpgradeStateGuard &&other) noexcept;

    FirmwareUpgradeStateGuard(const FirmwareUpgradeStateGuard &other)            = delete;
    FirmwareUpgradeStateGuard &operator=(const FirmwareUpgradeStateGuard &other) = delete;

    virtual void preUpdate() override;
    virtual void postUpdate() override;

protected:
    IDevice *owner_;
};

class GlobalTimestampGuard : public IFirmwareUpdateGuard {
public:
    explicit GlobalTimestampGuard(IDevice *owner);
    virtual ~GlobalTimestampGuard() noexcept override = default;

    GlobalTimestampGuard(GlobalTimestampGuard &&other) noexcept;
    GlobalTimestampGuard &operator=(GlobalTimestampGuard &&other) noexcept;

    GlobalTimestampGuard(const GlobalTimestampGuard &other)            = delete;
    GlobalTimestampGuard &operator=(const GlobalTimestampGuard &other) = delete;

    virtual void preUpdate() override;
    virtual void postUpdate() override;

protected:
    IDevice *owner_;
    bool     isGlobalTimestampEnabled_;

    std::shared_ptr<GlobalTimestampFitter> globalTimestampFilter_;
};

class HeardbeatGuard : public IFirmwareUpdateGuard {
public:
    explicit HeardbeatGuard(IDevice *owner);
    virtual ~HeardbeatGuard() noexcept override = default;

    HeardbeatGuard(HeardbeatGuard &&other) noexcept;
    HeardbeatGuard &operator=(HeardbeatGuard &&other) noexcept;

    HeardbeatGuard(const HeardbeatGuard &other)            = delete;
    HeardbeatGuard &operator=(const HeardbeatGuard &other) = delete;

    virtual void preUpdate() override;
    virtual void postUpdate() override;

protected:
    IDevice *owner_;
    bool     isHeartrateEnabled_;

    std::shared_ptr<DeviceMonitor> deviceMonitor_;
};
}  // namespace libobsensor